StorageManager *
EntityManagerImpl::lookupStorageType(const StringC &type,
const CharsetInfo &docCharset) const
{
if (type.size() == 0)
return 0;
if (matchKey(type, defaultStorageManager_->type(), docCharset))
return defaultStorageManager_.pointer();
for (size_t i = 0; i < storageManagers_.size(); i++)
if (matchKey(type, storageManagers_[i]->type(), docCharset))
return storageManagers_[i].pointer();
return 0;
}
Boolean FSIParser::setCatalogAttributes(ParsedSystemId &parsedSysid)
{
Boolean hadPublic = 0;
parsedSysid.maps.resize(parsedSysid.maps.size() + 1);
parsedSysid.maps.back().type = ParsedSystemIdMap::catalogDocument;
for (;;) {
StringC token, value;
Boolean gotValue;
if (!parseAttribute(token, gotValue, value)) {
mgr_.message(EntityManagerMessages::fsiSyntax, StringMessageArg(str_));
return 0;
}
if (token.size() == 0)
break;
if (matchKey(token, "PUBLIC")) {
if (hadPublic)
mgr_.message(EntityManagerMessages::fsiDuplicateAttribute,
StringMessageArg(idCharset_.execToDesc("PUBLIC")));
else if (gotValue) {
convertMinimumLiteral(value, parsedSysid.maps.back().publicId);
parsedSysid.maps.back().type = ParsedSystemIdMap::catalogPublic;
}
else
mgr_.message(EntityManagerMessages::fsiMissingValue,
StringMessageArg(token));
hadPublic = 1;
}
else
mgr_.message(gotValue
? EntityManagerMessages::fsiUnsupportedAttribute
: EntityManagerMessages::fsiUnsupportedAttributeToken,
StringMessageArg(token));
}
return 1;
}
Boolean FSIParser::lookupRecords(const StringC &token,
StorageObjectSpec::Records &result)
{
for (size_t i = 0; i < SIZEOF(recordTypeTable); i++)
if (matchKey(token, recordTypeTable[i].name)) {
result = recordTypeTable[i].value;
return 1;
}
return 0;
}
const InputCodingSystem *
EntityManagerImpl::lookupCodingSystem(const StringC &type,
const CharsetInfo &docCharset,
const char *&name) const
{
for (size_t i = 0; i < codingSystems_.size(); i++)
if (matchKey(type, codingSystems_[i].name, docCharset)) {
name = codingSystems_[i].name;
return codingSystems_[i].ics;
}
return 0;
}
StorageManager *FSIParser::lookupStorageType(const StringC &key,
Boolean &neutral)
{
if (matchKey(key, "NEUTRAL")) {
neutral = 1;
if (defSpec_ && defSpec_->storageManager->inheritable())
return defSpec_->storageManager;
else
return em_->defaultStorageManager_.pointer();
}
else {
StorageManager *sm = em_->lookupStorageType(key, idCharset_);
if (sm)
neutral = 0;
return sm;
}
}
static int
findSpliceSystemAndRemove(
const char *domainName,
os_time serviceTerminatePeriod)
{
DIR *key_dir;
struct dirent *entry;
char *shmName;
int retCode = OSPL_EXIT_CODE_OK;
char * dir_name = NULL;
char * key_file_name = NULL;
int key_file_name_size;
dir_name = os_getTempDir();
key_dir = opendir (dir_name);
if (key_dir)
{
entry = readdir (key_dir);
while (entry != NULL)
{
if (strncmp (entry->d_name, "spddskey_", 9) == 0)
{
key_file_name_size = strlen(dir_name) + strlen(key_file_format) + 2;
key_file_name = os_malloc (key_file_name_size);
snprintf (key_file_name, key_file_name_size, "%s/%s", dir_name, entry->d_name);
if ((shmName = matchKey (key_file_name, domainName)))
{
retCode = shutdownDDS (key_file_name, shmName, serviceTerminatePeriod);
os_free (shmName);
}
os_free(key_file_name);
}
entry = readdir (key_dir);
}
closedir (key_dir);
} else
{
/* unrecoverable */
retCode = OSPL_EXIT_CODE_UNRECOVERABLE_ERROR;
}
return retCode;
}
Boolean FSIParser::setAttributes(StorageObjectSpec &sos,
Boolean neutral,
Xchar &smcrd,
Boolean &fold)
{
Boolean hadBctf = 0;
Boolean hadTracking = 0;
Boolean hadSmcrd = 0;
smcrd = -1;
fold = 1;
Boolean hadRecords = 0;
Boolean hadBase = 0;
Boolean hadZapeof = 0;
Boolean hadSearch = 0;
Boolean hadFold = 0;
StorageObjectSpec::Records records;
setDefaults(sos);
for (;;) {
StringC token, value;
Boolean gotValue;
if (!parseAttribute(token, gotValue, value)) {
mgr_.message(EntityManagerMessages::fsiSyntax, StringMessageArg(str_));
return 0;
}
if (token.size() == 0)
break;
if (matchKey(token, "BCTF")) {
if (sos.storageManager->requiredCodingSystem())
mgr_.message(EntityManagerMessages::fsiBctfNotApplicable);
else if (hadBctf)
mgr_.message(EntityManagerMessages::fsiDuplicateAttribute,
StringMessageArg(token));
else if (gotValue) {
const char *codingSystemName;
const InputCodingSystem *codingSystem
= em_->lookupCodingSystem(value, idCharset_, codingSystemName);
if (codingSystem) {
sos.codingSystem = codingSystem;
sos.codingSystemName = codingSystemName;
}
else if (matchKey(value, "SAME")) {
if (isNdata_) {
if (defSpec_) {
sos.codingSystem = defSpec_->codingSystem;
sos.codingSystemName = defSpec_->codingSystemName;
}
else {
sos.codingSystem = em_->defaultCodingSystem_;
sos.codingSystemName = 0;
}
}
}
else
mgr_.message(EntityManagerMessages::fsiUnknownBctf,
StringMessageArg(value));
}
else
mgr_.message(EntityManagerMessages::fsiMissingValue,
StringMessageArg(token));
hadBctf = 1;
}
else if (matchKey(token, "TRACKING")) {
if (hadTracking)
mgr_.message(EntityManagerMessages::fsiDuplicateAttribute,
StringMessageArg(token));
else if (gotValue) {
if (matchKey(value, "NOTRACK"))
sos.notrack = 1;
else if (!matchKey(value, "TRACK"))
mgr_.message(EntityManagerMessages::fsiBadTracking,
StringMessageArg(value));
}
else
mgr_.message(EntityManagerMessages::fsiMissingValue,
StringMessageArg(token));
hadTracking = 1;
}
else if (matchKey(token, "ZAPEOF")) {
if (sos.storageManager->requiredCodingSystem())
mgr_.message(EntityManagerMessages::fsiZapeofNotApplicable);
else if (hadZapeof)
mgr_.message(EntityManagerMessages::fsiDuplicateAttribute,
StringMessageArg(token));
else if (gotValue) {
if (matchKey(value, "ZAPEOF"))
sos.zapEof = 1;
else if (matchKey(value, "NOZAPEOF"))
sos.zapEof = 0;
else
mgr_.message(EntityManagerMessages::fsiBadZapeof,
StringMessageArg(value));
}
else
sos.zapEof = 1;
hadZapeof = 1;
}
else if (matchKey(token, "NOZAPEOF")) {
if (sos.storageManager->requiredCodingSystem())
mgr_.message(EntityManagerMessages::fsiZapeofNotApplicable);
else if (hadZapeof)
mgr_.message(EntityManagerMessages::fsiDuplicateAttribute,
StringMessageArg(idCharset_.execToDesc("ZAPEOF")));
else if (gotValue)
mgr_.message(EntityManagerMessages::fsiValueAsName,
StringMessageArg(token));
else
sos.zapEof = 0;
hadZapeof = 1;
}
else if (matchKey(token, "SEARCH")) {
if (hadSearch)
mgr_.message(EntityManagerMessages::fsiDuplicateAttribute,
StringMessageArg(token));
else if (gotValue) {
if (matchKey(value, "SEARCH"))
sos.search = 1;
else if (matchKey(value, "NOSEARCH"))
sos.search = 0;
else
mgr_.message(EntityManagerMessages::fsiBadSearch,
StringMessageArg(value));
}
else
sos.search = 1;
hadSearch = 1;
}
else if (matchKey(token, "NOSEARCH")) {
if (hadSearch)
mgr_.message(EntityManagerMessages::fsiDuplicateAttribute,
StringMessageArg(idCharset_.execToDesc("SEARCH")));
else if (gotValue)
mgr_.message(EntityManagerMessages::fsiValueAsName,
StringMessageArg(token));
else
sos.search = 0;
hadSearch = 1;
}
else if (matchKey(token, "FOLD")) {
if (!neutral)
mgr_.message(EntityManagerMessages::fsiFoldNotNeutral);
else if (hadFold)
mgr_.message(EntityManagerMessages::fsiDuplicateAttribute,
StringMessageArg(token));
else if (gotValue) {
if (matchKey(value, "FOLD"))
fold = 1;
else if (matchKey(value, "NOFOLD"))
fold = 0;
else
mgr_.message(EntityManagerMessages::fsiBadFold,
StringMessageArg(value));
}
else
fold = 1;
hadFold = 1;
}
else if (matchKey(token, "NOFOLD")) {
if (!neutral)
mgr_.message(EntityManagerMessages::fsiFoldNotNeutral);
else if (hadFold)
mgr_.message(EntityManagerMessages::fsiDuplicateAttribute,
StringMessageArg(idCharset_.execToDesc("FOLD")));
else if (gotValue)
mgr_.message(EntityManagerMessages::fsiValueAsName,
StringMessageArg(token));
else
fold = 0;
hadFold = 1;
}
else if (matchKey(token, "SMCRD")) {
if (hadSmcrd)
mgr_.message(EntityManagerMessages::fsiDuplicateAttribute,
StringMessageArg(token));
else if (gotValue) {
if (value.size() == 0)
smcrd = -1;
else if (value.size() == 1)
smcrd = value[0];
else
mgr_.message(EntityManagerMessages::fsiBadSmcrd,
StringMessageArg(value));
}
else
mgr_.message(EntityManagerMessages::fsiMissingValue,
StringMessageArg(token));
hadSmcrd = 1;
}
else if (matchKey(token, "RECORDS")) {
if (sos.storageManager->requiresCr())
mgr_.message(EntityManagerMessages::fsiRecordsNotApplicable);
else if (hadRecords)
mgr_.message(EntityManagerMessages::fsiDuplicateAttribute,
StringMessageArg(token));
else if (gotValue) {
if (!lookupRecords(value, sos.records))
mgr_.message(EntityManagerMessages::fsiUnsupportedRecords,
StringMessageArg(value));
}
else
mgr_.message(EntityManagerMessages::fsiMissingValue,
StringMessageArg(token));
hadRecords = 1;
}
else if (matchKey(token, "SOIBASE")) {
if (hadBase)
mgr_.message(EntityManagerMessages::fsiDuplicateAttribute,
StringMessageArg(token));
else if (gotValue)
value.swap(sos.baseId);
else {
mgr_.message(EntityManagerMessages::fsiMissingValue,
StringMessageArg(token));
sos.baseId.resize(0);
}
hadBase = 1;
}
else if (lookupRecords(token, records)) {
if (sos.storageManager->requiresCr())
mgr_.message(EntityManagerMessages::fsiRecordsNotApplicable);
else if (hadRecords)
mgr_.message(EntityManagerMessages::fsiDuplicateAttribute,
StringMessageArg(idCharset_.execToDesc("RECORDS")));
else if (!gotValue)
sos.records = records;
else
mgr_.message(EntityManagerMessages::fsiValueAsName,
StringMessageArg(token));
hadRecords = 1;
}
else if (matchKey(token, "NOTRACK")) {
if (hadTracking)
mgr_.message(EntityManagerMessages::fsiDuplicateAttribute,
StringMessageArg(idCharset_.execToDesc("TRACKING")));
else if (!gotValue)
sos.notrack = 1;
else
mgr_.message(EntityManagerMessages::fsiValueAsName,
StringMessageArg(token));
hadTracking = 1;
}
else if (matchKey(token, "TRACK")) {
if (hadTracking)
mgr_.message(EntityManagerMessages::fsiDuplicateAttribute,
StringMessageArg(idCharset_.execToDesc("TRACKING")));
else if (gotValue)
mgr_.message(EntityManagerMessages::fsiValueAsName,
StringMessageArg(token));
hadTracking = 1;
}
else
mgr_.message(gotValue
? EntityManagerMessages::fsiUnsupportedAttribute
: EntityManagerMessages::fsiUnsupportedAttributeToken,
StringMessageArg(token));
}
if (hadBase && sos.baseId.size() > 0) {
convertId(sos.baseId, smcrd, sos.storageManager);
if (neutral) {
if (!sos.storageManager->transformNeutral(sos.baseId, fold, mgr_))
sos.baseId.resize(0);
}
}
if (!hadZapeof && hadRecords && sos.records == StorageObjectSpec::asis)
sos.zapEof = 0;
return 1;
}
Boolean FSIParser::parse(ParsedSystemId &parsedSysid)
{
size_t startIndex = strIndex_;
if (!matchChar(get(), '<'))
return handleInformal(startIndex, parsedSysid);
StringC key;
for (;;) {
Xchar c = get();
if (c == -1)
return handleInformal(startIndex, parsedSysid);
if (isS(c) || matchChar(c, '>'))
break;
key += Char(c);
}
unget();
if (matchKey(key, "CATALOG")) {
if (!setCatalogAttributes(parsedSysid))
return 0;
return parse(parsedSysid);
}
Boolean neutral;
StorageManager *sm = lookupStorageType(key, neutral);
if (!sm)
return handleInformal(startIndex, parsedSysid);
for (;;) {
parsedSysid.resize(parsedSysid.size() + 1);
StorageObjectSpec &sos = parsedSysid.back();
sos.storageManager = sm;
Xchar smcrd;
Boolean fold;
if (!setAttributes(sos, neutral, smcrd, fold))
return 0;
sm = 0;
StringC id;
Boolean hadData = 0;
for (;;) {
Xchar c = get();
if (c == -1)
break;
if (matchChar(c, '<')) {
hadData = 1;
Char stago = c;
key.resize(0);
for (;;) {
c = get();
if (c == -1) {
id += stago;
id += key;
break;
}
if (isS(c) || matchChar(c, '>')) {
unget();
sm = lookupStorageType(key, neutral);
if (!sm) {
id += stago;
id += key;
}
break;
}
key += c;
}
if (sm)
break;
}
else if (!((!hadData && matchChar(c, '\r')) // ignored RE
|| matchChar(c, '\n') )) { // ignored RS
hadData = 1;
id += c;
}
}
if (id.size() > 0 && matchChar(id[id.size() - 1], '\r'))
id.resize(id.size() - 1);
uncharref(id);
id.swap(sos.specId);
if (!convertId(sos.specId, smcrd, sos.storageManager))
return 0;
if (neutral) {
if (!sos.storageManager->transformNeutral(sos.specId, fold, mgr_))
return 0;
}
if (sos.storageManager->resolveRelative(sos.baseId, sos.specId,
sos.search))
sos.baseId.resize(0);
if (!sm)
break;
}
return 1;
}
Action::ID Input::feedEvent(const sf::Event& event)
{
switch (event.type)
{
case sf::Event::KeyPressed:
{
Action::ID action = matchKey(event.key.code);
if (action != Action::NONE)
s_pressed[action] = true;
return action;
}
case sf::Event::KeyReleased:
{
Action::ID action = matchKey(event.key.code);
if (action != Action::NONE)
s_pressed[action] = false;
break;
}
case sf::Event::JoystickButtonPressed:
{
Action::ID action = matchButton(event.joystickButton.button);
if (action != Action::NONE)
s_pressed[action] = true;
return action;
}
case sf::Event::JoystickButtonReleased:
{
Action::ID action = matchButton(event.joystickButton.button);
if (action != Action::NONE)
s_pressed[action] = false;
break;
}
case sf::Event::JoystickMoved:
if (event.joystickMove.axis == sf::Joystick::X)
{
if (event.joystickMove.position > s_joystick_deadzone)
{
s_pressed[Action::RIGHT] = true;
return Action::RIGHT;
}
s_pressed[Action::RIGHT] = false;
if (event.joystickMove.position < -s_joystick_deadzone)
{
s_pressed[Action::LEFT] = true;
return Action::LEFT;
}
s_pressed[Action::LEFT] = false;
}
else if (event.joystickMove.axis == sf::Joystick::Y)
{
if (event.joystickMove.position > s_joystick_deadzone)
{
s_pressed[Action::DOWN] = true;
return Action::DOWN;
}
s_pressed[Action::DOWN] = false;
if (event.joystickMove.position < -s_joystick_deadzone)
{
s_pressed[Action::UP] = true;
return Action::UP;
}
s_pressed[Action::UP] = false;
}
break;
case sf::Event::Closed:
return Action::EXIT_APP;
default:
break;
}
return Action::NONE;
}
xarg *
Yap_ArgListToVector (Term listl, const param_t *def, int n)
{
CACHE_REGS
xarg *a = calloc( n , sizeof(xarg) );
if (IsApplTerm(listl) && FunctorOfTerm(listl) == FunctorModule)
listl = ArgOfTerm(2,listl);
if (!IsPairTerm(listl) && listl != TermNil) {
if (IsVarTerm(listl) ) {
free( a );
LOCAL_Error_TYPE = INSTANTIATION_ERROR;
LOCAL_Error_Term = listl;
return NULL;
}
if (IsAtomTerm(listl) ) {
xarg *na = matchKey( AtomOfTerm(listl), a, n, def);
if (!na) {
free( a );
LOCAL_Error_TYPE = TYPE_ERROR_LIST;
LOCAL_Error_Term = listl;
return NULL;
}
} else if (IsApplTerm(listl)) {
Functor f = FunctorOfTerm( listl );
if (IsExtensionFunctor(f)) {
free( a );
LOCAL_Error_TYPE = TYPE_ERROR_LIST;
LOCAL_Error_Term = listl;
return NULL;
}
arity_t arity = ArityOfFunctor( f );
if (arity != 1) {
free( a );
LOCAL_Error_TYPE = TYPE_ERROR_LIST;
LOCAL_Error_Term = listl;
return NULL;
}
xarg *na = matchKey( NameOfFunctor( f ), a, n, def);
if (!na) {
free( a );
LOCAL_Error_TYPE = TYPE_ERROR_LIST;
LOCAL_Error_Term = listl;
return NULL;
}
} else {
free( a );
LOCAL_Error_TYPE = TYPE_ERROR_LIST;
LOCAL_Error_Term = listl;
return NULL;
}
listl = MkPairTerm( listl, TermNil );
}
while (IsPairTerm(listl)) {
Term hd = HeadOfTerm( listl );
listl = TailOfTerm( listl );
if (IsVarTerm(hd) || IsVarTerm(listl)) {
LOCAL_Error_TYPE = INSTANTIATION_ERROR;
if (IsVarTerm(hd)) {
LOCAL_Error_Term = hd;
} else {
LOCAL_Error_Term = listl;
}
free( a );
return NULL;
}
if (IsAtomTerm(hd)) {
xarg *na = matchKey( AtomOfTerm( hd ), a, n, def);
if (!na)
return NULL;
na->used = true;
na->tvalue = TermNil;
continue;
} else if (IsApplTerm( hd )) {
Functor f = FunctorOfTerm( hd );
if (IsExtensionFunctor(f)) {
LOCAL_Error_TYPE = TYPE_ERROR_PARAMETER;
LOCAL_Error_Term = hd;
free( a );
return NULL;
}
arity_t arity = ArityOfFunctor( f );
if (arity != 1) {
LOCAL_Error_TYPE = DOMAIN_ERROR_OUT_OF_RANGE;
LOCAL_Error_Term = hd;
free( a );
return NULL;
}
xarg *na = matchKey( NameOfFunctor( f ), a, n, def);
if (!na) {
free( a );
return NULL;
}
na->used = 1;
na->tvalue = ArgOfTerm(1, hd);
} else {
LOCAL_Error_TYPE = TYPE_ERROR_PARAMETER;
free( a );
return NULL;
}
}
if (IsVarTerm(listl)) {
LOCAL_Error_TYPE = INSTANTIATION_ERROR;
LOCAL_Error_Term = listl;
free( a );
return NULL;
} else if (listl != TermNil) {
LOCAL_Error_TYPE = TYPE_ERROR_LIST;
LOCAL_Error_Term = listl;
free( a );
return NULL;
}
return a;
}