Model::Root::Ptr ProjectImpl::parseFile(const QString& fileName) {
LexicalAnalyzer::Ptr la = analyze(fileName);
if (!hasErrors()) {
Q_ASSERT(la);
Model::Root::Ptr model = parseStream(la->tokenStream());
if (model) {
if (testOption(optDumpCodeModel)) {
QFileInfo fi(fileName);
QString modelFileName =
fi.absolutePath() %
fi.completeBaseName() %
QLatin1Literal(".pmodel");
if (!model->exportModel(modelFileName)) {
errors()->emitError("Could not export model for file.", fileName);
}
}
return model;
}
}
return NULL;
}
void loadTexture(char * fileName, int textureID) {
FILE *fp;
int i, j, c;
if ((fp = fopen(fileName, "r")) == 0) {
printf("Error, failed to find the \"%s\".\n", fileName);
exit(0);
}
parseStream(fp);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glBindTexture(GL_TEXTURE_2D, texNames[textureID]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, colourMap);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
fclose(fp);
}
int
main (int argc, char* argv[])
{
Node *result;
READ_OPTIONS_AND_INIT("testvisit", "Run visit function on input for testing.");
// read from terminal
if (getStringOption("input.sql") == NULL)
{
result = parseStream(stdin);
DEBUG_LOG("Address of returned node is <%p>", result);
ERROR_LOG("PARSE RESULT FROM STREAM IS <%s>", beatify(nodeToString(result)));
}
// parse input string
else
{
result = parseFromString(getStringOption("input.sql"));
DEBUG_LOG("Address of returned node is <%p>", result);
ERROR_LOG("PARSE RESULT FROM STRING IS:\n%s", nodeToString(result));
ERROR_LOG("PARSE RESULT FROM STRING IS:\n%s", beatify(nodeToString(result)));
}
void *state = NULL;
visitTheNode(result, state);
return shutdownApplication();
}
Vic2::Relations::Relations(const std::string& theTag, std::istream& theStream):
tag(theTag)
{
registerKeyword(std::regex("value"), [this](const std::string& unused, std::istream& theStream){
commonItems::singleInt valueInt(theStream);
value = valueInt.getInt();
});
registerKeyword(std::regex("level"), [this](const std::string& unused, std::istream& theStream){
commonItems::singleInt levelInt(theStream);
level = levelInt.getInt();
});
registerKeyword(std::regex("military_access"), [this](const std::string& unused, std::istream& theStream){
commonItems::singleString stateString(theStream);
militaryAccess = (stateString.getString() == "yes");
});
registerKeyword(std::regex("last_send_diplomat"), [this](const std::string& unused, std::istream& theStream){
commonItems::singleString dateString(theStream);
lastSentDiplomat = date(dateString.getString());
});
registerKeyword(std::regex("last_war"), [this](const std::string& unused, std::istream& theStream){
commonItems::singleString dateString(theStream);
lastWar = date(dateString.getString());
});
registerKeyword(std::regex("truce_until"), [this](const std::string& unused, std::istream& theStream){
commonItems::singleString dateString(theStream);
truceUntil = date(dateString.getString());
});
registerKeyword(std::regex("[A-Za-z0-9_]+"), commonItems::ignoreItem);
parseStream(theStream);
}
int
main (int argc, char* argv[])
{
Node *result;
Node *qoModel;
char *sql;
READ_OPTIONS_AND_INIT("testtranslate", "Run all stages on input except provenance rewrite and output rewritten SQL code.");
// read from terminal
if (getStringOption("input.sql") == NULL)
{
result = parseStream(stdin);
DEBUG_LOG("Address of returned node is <%p>", result);
ERROR_LOG("PARSE RESULT FROM STREAM IS <%s>", beatify(nodeToString(result)));
}
// parse input string
else
{
result = parseFromString(getStringOption("input.sql"));
DEBUG_LOG("Address of returned node is <%p>", result);
ERROR_LOG("PARSE RESULT FROM STRING IS:\n%s", beatify(nodeToString(result)));
}
qoModel = translateParse(result);
INFO_LOG("TRANSLATION RESULT FROM STRING IS:\n%s", beatify(nodeToString(qoModel)));
ERROR_LOG("SIMPLIFIED OPERATOR TREE:\n%s", operatorToOverviewString(qoModel));
sql = serializeOperatorModel(qoModel);
ERROR_LOG("SERIALIZED SQL:\n%s", sql);
return shutdownApplication();
}
void Packed::poll(bool can_read)
{
if (!can_read) return;
m_socket.peek();
std::streamsize count;
while ((count = m_socket.rdbuf()->in_avail()) > 0) {
for (int i = 0; i < count; ++i) {
int next = m_socket.rdbuf()->sbumpc();
switch (m_state.top())
{
case PARSE_STREAM: parseStream(next); break;
case PARSE_MAP: parseMap(next); break;
case PARSE_LIST: parseList(next); break;
case PARSE_MAP_BEGIN: parseMapBegin(next); break;
case PARSE_LIST_BEGIN: parseListBegin(next); break;
case PARSE_INT: parseInt(next); break;
case PARSE_FLOAT: parseFloat(next); break;
case PARSE_STRING: parseString(next); break;
case PARSE_NAME: parseName(next); break;
}
}
}
}
std::pair<bool, std::string>
SimForth::interpreteCell(ASpreadSheetCell &cell)
{
m_err_stream = 0;
STREAM.loadString(cell.formulae(), cell.name());
Cell32 value;
std::pair<bool, std::string> res = parseStream();
if (true == res.first)
{
try
{
DPOP(value);
isStackUnderOverFlow(forth::DataStack);
cell.value(value);
}
catch (ForthException const& e)
{
res = std::make_pair(false, e.message());
}
}
std::cout << "interpretCell '" << cell.formulae() << "': "
<< res.second << std::endl;
if (true == res.first)
{
std::cout << "Result " << value << std::endl;
}
return res;
}
void dl_vlive_live(std::string url)
{
streamInfo currentInfo;
vidUrlInfo currentLiveInfo;
m3u8Info currentMediaInfo;
std::string v_title;
std::string strUrl;
int cnt = 0;
float time = 0;
getStreamInfo(retrievePage((char *)url.c_str()), ¤tInfo, NULL, TYPE_VLIVE);
getStreamInfo(retrievePage((char *)url.c_str()), NULL, ¤tLiveInfo, TYPE_VLIVE_LIVE);
for (int i = 0; i <= currentLiveInfo.num_list; i++)
modifyUrl(¤tLiveInfo.url[i], TYPE_VLIVE_LIVE);
printLine(3);
getline(cin, v_title);
printLine(5);
while (strcmp(currentInfo.v_stat.c_str(), "LIVE_END") != 0)
{
parseStream(retrievePage((char*)currentLiveInfo.url[currentLiveInfo.num_list].c_str()), ¤tMediaInfo);
for (int i = 0; i <= currentMediaInfo.list_num; i++)
{
strUrl = "http://vlive.hls.edgesuite.net/" + parseUrl(currentLiveInfo.url[currentLiveInfo.num_list]) + currentMediaInfo.fname[i];
retrieveFileFromUrl(strUrl, v_title, TYPE_VLIVE_LIVE, cnt, &time);
std::this_thread::sleep_for(std::chrono::milliseconds((int)(currentMediaInfo.sec_sleep[i] - time) - 250));
cnt++;
}
getStreamInfo(retrievePage((char *)url.c_str()), ¤tInfo, NULL, TYPE_VLIVE);
}
cout << v_title;
printLine(6);
}
bool parsepdf(const char* filename) {
PoDoFo::PdfVecObjects objects;
PoDoFo::PdfParser parser(&objects, filename);
PoDoFo::TIVecObjects it = objects.begin();
bool result = false;
do {
PoDoFo::PdfObject *obj = (*it);
#if (PODOFO_VERSION_MAJOR > 0) || (PODOFO_VERSION_MINOR > 8) || (PODOFO_VERSION_PATCH >= 3)
if (obj->HasStream() && (obj->GetObjectLength(PoDoFo::ePdfWriteMode_Compact) > 10000)) {
#else
if (obj->HasStream() && (obj->GetObjectLength() > 10000)) {
#endif
PoDoFo::PdfStream *stream = obj->GetStream();
char *buffer;
PoDoFo::pdf_long bufferLen;
stream->GetFilteredCopy(&buffer, &bufferLen);
//std::cerr << "Buffer length : " << bufferLen << std::endl;
if (bufferLen > 1000)
result = parseStream(buffer, bufferLen);
free(buffer);
}
it++;
} while (it != objects.end());
return result;
}
int main(int argc, char** argv) {
if (argc != 2) {
std::cerr << "ERROR: wrong number of argument" << std::endl;
return -1;
} else {
parsepdf(argv[1]);
}
}
colonialRegion::colonialRegion(std::istream& theStream)
{
registerKeyword(std::regex("color"), [this](const std::string& unused, std::istream& theStream)
{
commonItems::Color unusedColor(theStream);
});
registerKeyword(std::regex("tax_income"), commonItems::ignoreObject);
registerKeyword(std::regex("native_size"), commonItems::ignoreObject);
registerKeyword(std::regex("native_ferocity"), commonItems::ignoreObject);
registerKeyword(std::regex("native_hostileness"), commonItems::ignoreObject);
registerKeyword(std::regex("trade_goods"), commonItems::ignoreObject);
registerKeyword(std::regex("culture"), commonItems::ignoreObject);
registerKeyword(std::regex("religion"), commonItems::ignoreObject);
registerKeyword(std::regex("names"), commonItems::ignoreObject);
registerKeyword(std::regex("provinces"), [this](const std::string& unused, std::istream& theStream)
{
auto equals = getNextToken(theStream);
commonItems::intList theProvinces(theStream);
auto provincesVector = theProvinces.getInts();
std::for_each(provincesVector.begin(), provincesVector.end(), [this](const int& province)
{
provinces.insert(province);
}
);
}
);
parseStream(theStream);
}
CppCompoundPtr CppParser::parseFile(const std::string& filename)
{
auto stm = readFile(filename);
auto cppCompound = parseStream(stm.data(), stm.size());
if (!cppCompound)
return cppCompound;
cppCompound->name(filename);
return cppCompound;
}
void runNrlIndexFromStream(bt *btr, uchar *stream, d_l_t *nrlind, int itbl) {
aobj akey;
convertStream2Key(stream, &akey, btr);
void *rrow = parseStream(stream, btr);
/* create command and run it */
sds cmd = genNRL_Cmd(btr, nrlind, &akey, NULL, NULL, rrow, itbl);
//printf("run_nri: cmd: %s\n", cmd);
runCmdInFakeClient(cmd);
sdsfree(cmd); /* DESTROYED 016 */
releaseAobj(&akey);
}
/**
*
* This function will throw an IllegalArgumentException if the file contents cannot be multibyte decoded.
*/
void PropertiesConfiguration::load(const String &file) {
// std::clog << "Loading properties file: " << file << std::endl;
std::ifstream input(file.c_str(), std::ifstream::in);
// fail() catches File Not Found, bad() does not.
ASSERT(!input.fail());
if (input.fail())
throw FileNotFoundException("Failed to open file for read: " + file);
parseStream(input);
}
bool ossimApplanixEOFile::parseFile(const ossimFilename& file)
{
bool result = false;
std::shared_ptr<ossim::istream> in = ossim::StreamFactoryRegistry::instance()->
createIstream(file, std::ios_base::in);
if ( in )
{
result = parseStream( *in );
}
return result;
}
ConfigErrorCode Config::parseFile(const char *fileName)
{
FILE *stream = fopen(fileName, "r");
if (stream == NULL) {
if (errno == ENOENT || errno == ENOTDIR)
return setErrorCode(kConfigFileMissingErr);
else if (errno == EACCES)
return setErrorCode(kConfigFileNoAccessErr);
return setErrorCode(kConfigOpenFileErr);
}
ConfigErrorCode status = parseStream(stream);
if (status == kConfigParseStreamErr)
status = setErrorCode(kConfigParseFileErr);
fclose(stream);
return status;
}
static bool streamToBTEntry(uchar *stream, btSIter *siter, bt_n *x, int i) {
if (!stream) return 0;
if (i < 0) i = 0;
convertStream2Key(stream, siter->be.key, siter->x.btr);
siter->be.val = parseStream(stream, siter->x.btr);
bool gost = IS_GHOST(siter->x.btr, siter->be.val);
if (gost) {
siter->missed = 1; // GHOST key
siter->nim = 0;
}
siter->be.dr = x ? getDR(siter->x.btr, x, i) : 0;
siter->be.stream = stream;
siter->be.x = x;
siter->be.i = i; //NOTE: used by bt_validate_dirty
//DUMP_STREAM_TO_BT_ENTRY
return 1;
}
//*******************************************************************
// Private Method:
//*******************************************************************
bool ossimKeywordlist::parseFile(const ossimFilename& file,
bool ignoreBinaryChars)
{
if(!file.exists()) return false;
bool result = false;
std::ifstream is;
is.open(file.c_str(), std::ios::in | std::ios::binary);
if(!is.fail())
{
result = parseStream(is, ignoreBinaryChars);
}
is.close();
return result;
}
//*******************************************************************
// Private Method:
//*******************************************************************
bool ossimKeywordlist::parseFile(const ossimFilename& file,
bool ignoreBinaryChars)
{
std::ifstream is;
is.open(file.c_str(), std::ios::in | std::ios::binary);
if ( !is.is_open() )
{
// ESH 07/2008, Trac #234: OSSIM is case sensitive
// when using worldfile templates during ingest
// -- If first you don't succeed with the user-specified
// filename, try again with the results of a case insensitive search.
ossimDirectory directory(file.path());
ossimFilename filename(file.file());
std::vector<ossimFilename> result;
bool bSuccess = directory.findCaseInsensitiveEquivalents( filename, result );
if ( bSuccess == true )
{
int numResults = (int)result.size();
int i;
for ( i=0; i<numResults && !is.is_open(); ++i )
{
is.open( result[i].c_str(), std::ios::in | std::ios::binary );
}
}
if ( !is.is_open() )
{
if ( traceDebug() )
{
// report all errors that aren't existence problems.
// we want to know about things like permissions, too many open files, etc.
ossimNotify(ossimNotifyLevel_DEBUG)
<< "Error opening file: " << file.c_str() << std::endl;
}
return false;
}
}
bool result = parseStream(is, ignoreBinaryChars);
is.close();
return result;
}
void QTweetUserStream::replyReadyRead()
{
QByteArray response = m_reply->readAll();
#ifdef STREAM_LOGGER
m_streamLog.write(response);
m_streamLog.write("\n");
#endif
if (m_streamTryingReconnect) {
emit reconnected();
m_streamTryingReconnect = false;
}
//set backoff timer to initial interval
m_backofftimer->setInterval(20000);
QByteArray responseWithPreviousCache = response.prepend(m_cachedResponse);
int start = 0;
int end;
while ((end = responseWithPreviousCache.indexOf('\r', start)) != -1) {
if (start != end) {
QByteArray element = responseWithPreviousCache.mid(start, end - start);
if (!element.isEmpty()) {
emit stream(element);
parseStream(element);
}
}
int skip = (response.at(end + 1) == QLatin1Char('\n')) ? 2 : 1;
start = end + skip;
}
//undelimited part just cache it
m_cachedResponse.clear();
if (start != responseWithPreviousCache.size()) {
QByteArray element = responseWithPreviousCache.mid(start);
if (!element.isEmpty())
m_cachedResponse = element;
}
}
QString B9ModelLoader::DetermineFileType(QString filename, bool &readyRead)
{
QFileInfo info(filename);
QString suffix = info.suffix();
QFile parsefile(filename);
QTextStream parseStream(&parsefile);
QString asciiTest;
unsigned int i = 0;
if(suffix.toLower() == "stl")
{
//see if wee can open the file
if(!parsefile.open(QIODevice::ReadOnly | QIODevice::Text))
{
lastError = "Unable to open file:" + filename;
qDebug() << "B9UpdateLoader: Unable to open file: " << filename;
readyRead = false;
return "";
}
//we can get the byte count right away
byteCount = parsefile.size();
//now determine if the Stl is binary or ascii
while(i < 50)
{
parseStream >> asciiTest;
if(asciiTest.toLower().trimmed() == "facet")
{
parsefile.close();
qDebug() << "B9ModelLoader: the file is an ascii stl";
readyRead = true;
return "ASCII_STL";
}
i++;
}
//if we didnt find the string "facet within 50 words, assum its a bin.
qDebug() << "B9ModelLoader: the file is a binary stl";
readyRead = true;
parsefile.close();
return "BIN_STL";
}
else if(suffix.toLower() == "amf")
Vic2::State::State(std::istream& theStream, const string& ownerTag):
owner(ownerTag)
{
registerKeyword(std::regex("provinces"), [this](const std::string& unused, std::istream& theStream){
commonItems::intList provinceList(theStream);
for (auto province: provinceList.getInts())
{
provinceNums.insert(province);
}
});
registerKeyword(std::regex("state_buildings"), [this](const std::string& unused, std::istream& theStream){
Building theBuilding(theStream);
factoryLevel += theBuilding.getLevel();
});
registerKeyword(std::regex("[A-Za-z0-9_]+"), commonItems::ignoreItem);
parseStream(theStream);
setID();
}
int GraphicProducer::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: strikePath((*reinterpret_cast< const VectorPath(*)>(_a[1])),(*reinterpret_cast< const GraphicContext(*)>(_a[2]))); break;
case 1: fillPath((*reinterpret_cast< const VectorPath(*)>(_a[1])),(*reinterpret_cast< const GraphicContext(*)>(_a[2])),(*reinterpret_cast< Qt::FillRule(*)>(_a[3]))); break;
case 2: parsingDone((*reinterpret_cast< bool(*)>(_a[1]))); break;
case 3: { bool _r = parseStream((*reinterpret_cast< const char*(*)>(_a[1])),(*reinterpret_cast< ulong(*)>(_a[2])));
if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = _r; } break;
case 4: { bool _r = parsePDF((*reinterpret_cast< const QString(*)>(_a[1])));
if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = _r; } break;
default: ;
}
_id -= 5;
}
return _id;
}
static void
destroy_index(bt *ibtr, bt_n *n)
{
if (! n->leaf) {
for (int i = 0; i <= n->n; i++) {
destroy_index(ibtr, NODES(ibtr, n)[i]);
}
}
for (int i = 0; i < n->n; i++) {
void *be = KEYS(ibtr, n, i);
ai_nbtr *anbtr = (ai_nbtr *) parseStream(be, ibtr);
if (anbtr) {
if (anbtr->is_btree) {
bt_destroy(anbtr->u.nbtr);
} else {
ai_arr_destroy(anbtr->u.arr);
}
cf_free(anbtr);
}
}
}
int CHttpClientLink::processRecv()
{
mCode.clear();
int rt = receive(mCode);
if(rt==1)
{
int re = parseStream(mCode.content, mCode.length);
if(re == 1)
{
// httpResponseToApp(appKey, linkId(), version, rCode, content);
return -1;
}
else if(re<0)
{
return -1;
}
}
else if( -9 == rt || 0 == rt)
{
return -1;
}
return 1;
}
SidTune::LoadStatus SidTune::SID_fileSupport(Buffer_sidtt<const uint_least8_t>& dataBuf,
Buffer_sidtt<const uint_least8_t>& sidBuf)
{
uint_least32_t parseLen = sidBuf.len();
// Make sure SID buffer pointer is not zero.
// Check for a minimum file size. If it is smaller, we will not proceed.
if (parseLen<sidMinFileSize)
{
return LOAD_NOT_MINE;
}
// Here use a smart pointer to prevent access violation errors.
const char* pParseBuf = (const char*)sidBuf.get();
// First line has to contain the exact identification string.
if ( SidTuneTools::myStrNcaseCmp( pParseBuf, keyword_id ) == 0 )
{
// At least the ID was found, so set a default error message.
m_info.formatString = text_truncatedError;
// Defaults.
fileOffset = 0; // no header in separate data file
m_info.sidChipBase1 = 0xd400;
m_info.sidChipBase2 = 0;
m_info.musPlayer = false;
m_info.numberOfInfoStrings = 0;
uint_least32_t oldStyleSpeed = 0;
// Flags for required entries.
bool hasAddress = false,
hasName = false,
hasAuthor = false,
hasReleased = false,
hasSongs = false,
hasSpeed = false,
hasInitAddr = false;
// Using a temporary instance of an input string chunk.
#ifdef HAVE_EXCEPTIONS
char* pParseChunk = new(std::nothrow) char[parseChunkLen+1];
#else
char* pParseChunk = new char[parseChunkLen+1];
#endif
if ( pParseChunk == 0 )
{
m_info.formatString = text_noMemError;
return LOAD_ERROR;
}
// Parse as long we have not collected all ``required'' entries.
//while ( !hasAddress || !hasName || !hasAuthor || !hasCopyright
// || !hasSongs || !hasSpeed )
// Above implementation is wrong, we need to get all known
// fields and then check if all ``required'' ones were found.
do
{
uint_least32_t restLen;
{
const char* pNextLine = SidTuneTools::returnNextLine( pParseBuf, parseLen );
if ( pNextLine != 0 )
{
// Calculate number of chars between current pos and next line.
restLen = (uint_least32_t)(pNextLine - pParseBuf);
}
else
{
// Calculate number of chars between current pos and end of buf.
restLen = parseLen;
}
}
#ifdef HAVE_SSTREAM
std::string sParse( pParseBuf, restLen );
// Create whitespace eating (!) input string stream.
std::istringstream parseStream( sParse );
// A second one just for copying.
std::istringstream parseCopyStream( sParse );
#else
std::istrstream parseStream((char *) pParseBuf, restLen );
std::istrstream parseCopyStream((char *) pParseBuf, restLen );
#endif
if ( !parseStream || !parseCopyStream )
{
break;
}
// Now copy the next X characters except white-spaces.
for ( uint_least16_t i = 0; i < parseChunkLen; i++ )
{
char c;
parseCopyStream >> c;
pParseChunk[i] = c;
}
pParseChunk[parseChunkLen]=0;
// Now check for the possible keywords.
// ADDRESS
if ( SidTuneTools::myStrNcaseCmp( pParseChunk, keyword_address ) == 0 )
{
SidTuneTools::skipToEqu( parseStream );
m_info.loadAddr = (uint_least16_t)SidTuneTools::readHex( parseStream );
m_info.initAddr = m_info.loadAddr;
hasInitAddr = true;
if ( parseStream )
{
m_info.initAddr = (uint_least16_t)SidTuneTools::readHex( parseStream );
if ( !parseStream )
break;
m_info.playAddr = (uint_least16_t)SidTuneTools::readHex( parseStream );
hasAddress = true;
}
}
// NAME
else if ( SidTuneTools::myStrNcaseCmp( pParseChunk, keyword_name ) == 0 )
{
SidTuneTools::copyStringValueToEOL(pParseBuf,&infoString[0][0],SIDTUNE_MAX_CREDIT_STRLEN);
m_info.infoString[0] = &infoString[0][0];
hasName = true;
}
// AUTHOR
else if ( SidTuneTools::myStrNcaseCmp( pParseChunk, keyword_author ) == 0 )
{
SidTuneTools::copyStringValueToEOL(pParseBuf,&infoString[1][0],SIDTUNE_MAX_CREDIT_STRLEN);
m_info.infoString[1] = &infoString[1][0];
hasAuthor = true;
}
// COPYRIGHT
else if ( SidTuneTools::myStrNcaseCmp( pParseChunk, keyword_copyright ) == 0 )
{
SidTuneTools::copyStringValueToEOL(pParseBuf,&infoString[2][0],SIDTUNE_MAX_CREDIT_STRLEN);
m_info.infoString[2] = &infoString[2][0];
hasReleased = true;
}
// RELEASED
else if ( SidTuneTools::myStrNcaseCmp( pParseChunk, keyword_released ) == 0 )
{
SidTuneTools::copyStringValueToEOL(pParseBuf,&infoString[2][0],SIDTUNE_MAX_CREDIT_STRLEN);
m_info.infoString[2] = &infoString[2][0];
hasReleased = true;
}
// SONGS
else if ( SidTuneTools::myStrNcaseCmp( pParseChunk, keyword_songs ) == 0 )
{
SidTuneTools::skipToEqu( parseStream );
m_info.songs = (uint_least16_t)SidTuneTools::readDec( parseStream );
m_info.startSong = (uint_least16_t)SidTuneTools::readDec( parseStream );
hasSongs = true;
}
// SPEED
else if ( SidTuneTools::myStrNcaseCmp( pParseChunk, keyword_speed ) == 0 )
{
SidTuneTools::skipToEqu( parseStream );
oldStyleSpeed = SidTuneTools::readHex(parseStream);
hasSpeed = true;
}
// SIDSONG
else if ( SidTuneTools::myStrNcaseCmp( pParseChunk, keyword_musPlayer ) == 0 )
{
m_info.musPlayer = true;
}
// RELOC
else if ( SidTuneTools::myStrNcaseCmp( pParseChunk, keyword_reloc ) == 0 )
{
m_info.relocStartPage = (uint_least8_t)SidTuneTools::readHex( parseStream );
if ( !parseStream )
break;
m_info.relocPages = (uint_least8_t)SidTuneTools::readHex( parseStream );
}
// CLOCK
else if ( SidTuneTools::myStrNcaseCmp( pParseChunk, keyword_clock ) == 0 )
{
char clock[8];
SidTuneTools::copyStringValueToEOL(pParseBuf,clock,sizeof(clock));
if ( SidTuneTools::myStrNcaseCmp( clock, "UNKNOWN" ) == 0 )
m_info.clockSpeed = SIDTUNE_CLOCK_UNKNOWN;
else if ( SidTuneTools::myStrNcaseCmp( clock, "PAL" ) == 0 )
m_info.clockSpeed = SIDTUNE_CLOCK_PAL;
else if ( SidTuneTools::myStrNcaseCmp( clock, "NTSC" ) == 0 )
m_info.clockSpeed = SIDTUNE_CLOCK_NTSC;
else if ( SidTuneTools::myStrNcaseCmp( clock, "ANY" ) == 0 )
m_info.clockSpeed = SIDTUNE_CLOCK_ANY;
}
// SIDMODEL
else if ( SidTuneTools::myStrNcaseCmp( pParseChunk, keyword_sidModel ) == 0 )
{
char model[8];
SidTuneTools::copyStringValueToEOL(pParseBuf,model,sizeof(model));
if ( SidTuneTools::myStrNcaseCmp( model, "UNKNOWN" ) == 0 )
m_info.sidModel1 = SIDTUNE_SIDMODEL_UNKNOWN;
else if ( SidTuneTools::myStrNcaseCmp( model, "6581" ) == 0 )
m_info.sidModel1 = SIDTUNE_SIDMODEL_6581;
else if ( SidTuneTools::myStrNcaseCmp( model, "8580" ) == 0 )
m_info.sidModel1 = SIDTUNE_SIDMODEL_8580;
else if ( SidTuneTools::myStrNcaseCmp( model, "ANY" ) == 0 )
m_info.sidModel1 = SIDTUNE_SIDMODEL_ANY;
}
// COMPATIBILITY
else if ( SidTuneTools::myStrNcaseCmp( pParseChunk, keyword_compatibility ) == 0 )
{
char comp[6];
SidTuneTools::copyStringValueToEOL(pParseBuf,comp,sizeof(comp));
if ( SidTuneTools::myStrNcaseCmp( comp, "C64" ) == 0 )
m_info.compatibility = SIDTUNE_COMPATIBILITY_C64;
else if ( SidTuneTools::myStrNcaseCmp( comp, "PSID" ) == 0 )
m_info.compatibility = SIDTUNE_COMPATIBILITY_PSID;
else if ( SidTuneTools::myStrNcaseCmp( comp, "R64" ) == 0 )
m_info.compatibility = SIDTUNE_COMPATIBILITY_R64;
else if ( SidTuneTools::myStrNcaseCmp( comp, "BASIC" ) == 0 )
m_info.compatibility = SIDTUNE_COMPATIBILITY_BASIC;
}
parseLen -= restLen;
pParseBuf += restLen;
// Skip to next line. Leave loop, if none.
} while (parseLen != 0);
delete[] pParseChunk;
if ( !(hasName && hasAuthor && hasReleased && hasSongs) )
{ // Something is missing (or damaged ?).
// Error string set above.
return LOAD_ERROR;
}
switch ( m_info.compatibility )
{
case SIDTUNE_COMPATIBILITY_PSID:
case SIDTUNE_COMPATIBILITY_C64:
if ( !(hasAddress && hasSpeed) )
return LOAD_ERROR; // Error set above
break;
case SIDTUNE_COMPATIBILITY_R64:
if ( !(hasInitAddr || hasAddress) )
return LOAD_ERROR; // Error set above
// Allow user to provide single address
if ( !hasAddress )
m_info.loadAddr = 0;
else if ( m_info.loadAddr || m_info.playAddr )
{
m_info.formatString = text_invalidError;
return LOAD_ERROR;
}
// Deliberate run on
case SIDTUNE_COMPATIBILITY_BASIC:
oldStyleSpeed = ~0;
}
// Create the speed/clock setting table.
convertOldStyleSpeedToTables(oldStyleSpeed, m_info.clockSpeed);
m_info.numberOfInfoStrings = 3;
// We finally accept the input data.
m_info.formatString = text_format;
if ( m_info.musPlayer && !dataBuf.isEmpty() )
return MUS_load (dataBuf);
return LOAD_OK;
}
bool rspfApplanixEOFile::parseFile(const rspfFilename& file)
{
std::ifstream in(file.c_str());
return parseStream(in);
}
HoI4::Event::Event(const std::string& theType, std::istream& theStream):
type(theType)
{
registerKeyword(std::regex("id"), [this](const std::string& unused, std::istream& theStream)
{
commonItems::singleString idString(theStream);
id = idString.getString();
}
);
registerKeyword(std::regex("title"), [this](const std::string& unused, std::istream& theStream)
{
commonItems::singleString titleString(theStream);
title = titleString.getString();
}
);
registerKeyword(std::regex("desc"), [this](const std::string& unused, std::istream& theStream)
{
commonItems::stringOfItem descriptionString(theStream);
descriptions.push_back("desc " + descriptionString.getString());
}
);
registerKeyword(std::regex("picture"), [this](const std::string& unused, std::istream& theStream)
{
commonItems::singleString pictureString(theStream);
picture = pictureString.getString();
}
);
registerKeyword(std::regex("major"), [this](const std::string& unused, std::istream& theStream)
{
commonItems::singleString majorString(theStream);
majorEvent = (majorString.getString() == "yes");
}
);
registerKeyword(std::regex("is_triggered_only"), [this](const std::string& unused, std::istream& theStream)
{
commonItems::singleString triggeredString(theStream);
triggeredOnly = (triggeredString.getString() == "yes");
}
);
registerKeyword(std::regex("hidden"), [this](const std::string& unused, std::istream& theStream)
{
commonItems::singleString hiddenString(theStream);
hidden = (hiddenString.getString() == "yes");
}
);
registerKeyword(std::regex("trigger"), [this](const std::string& unused, std::istream& theStream)
{
commonItems::stringOfObject triggerString(theStream);
trigger = triggerString.getString();
}
);
registerKeyword(std::regex("mean_time_to_happen"), [this](const std::string& unused, std::istream& theStream)
{
commonItems::stringOfObject MTTHString(theStream);
meanTimeToHappen = MTTHString.getString();
}
);
registerKeyword(std::regex("immediate"), [this](const std::string& unused, std::istream& theStream)
{
commonItems::stringOfObject immediateString(theStream);
immediate = immediateString.getString();
}
);
registerKeyword(std::regex("option"), [this](const std::string& unused, std::istream& theStream)
{
commonItems::stringOfObject optionString(theStream);
options.push_back(optionString.getString());
}
);
parseStream(theStream);
}
bool ossimKeywordlist::parseString(const std::string& inString)
{
std::istringstream in(inString);
return parseStream(in);
}
bool ossimKeywordlist::parseStream(std::istream& is, bool /* ignoreBinaryChars */)
{
return parseStream(is);
}
void StyleSheetParser::parseString(const char *data, std::size_t len) {
parseStream(new StringInputStream(data, len));
}
