void FSIParser::uncharref(StringC &str)
{
size_t j = 0;
size_t i = 0;
while (i < str.size()) {
int digit;
if (matchChar(str[i], '&')
&& i + 2 < str.size()
&& matchChar(str[i + 1], '#')
&& convertDigit(str[i + 2], digit)) {
unsigned long val = digit;
i += 3;
while (i < str.size() && convertDigit(str[i], digit)) {
val = val*10 + digit;
i++;
}
str[j++] = val;
if (i < str.size() && matchChar(str[i], ';'))
i++;
}
else
str[j++] = str[i++];
}
str.resize(j);
}
void FSIParser::convertMinimumLiteral(const StringC &from, StringC &to)
{
// Do just enough to ensure it can be reparsed.
to.resize(0);
for (size_t i = 0; i < from.size(); i++) {
Char c = from[i];
if (matchChar(c, '"') || matchChar(c, '#'))
mgr_.message(EntityManagerMessages::fsiLookupChar, NumberMessageArg(c));
else if (matchChar(c, ' ')) {
if (to.size() && to[to.size() - 1] != c)
to += c;
}
else
to += c;
}
if (to.size() && matchChar(to[to.size() - 1], ' '))
to.resize(to.size() - 1);
}
void ParsedSystemId::unparse(const CharsetInfo &resultCharset,
StringC &result) const
{
size_t len = size();
result.resize(0);
size_t i;
for (i = 0; i < maps.size(); i++) {
if (maps[i].type == ParsedSystemIdMap::catalogDocument)
result += resultCharset.execToDesc("<CATALOG>");
else if (maps[i].type == ParsedSystemIdMap::catalogPublic) {
result += resultCharset.execToDesc("<CATALOG PUBLIC=\"");
result += maps[i].publicId;
result += resultCharset.execToDesc("\">");
}
}
for (i = 0; i < len; i++) {
const StorageObjectSpec &sos = (*this)[i];
result += resultCharset.execToDesc('<');
result += resultCharset.execToDesc(sos.storageManager->type());
if (sos.notrack)
result += resultCharset.execToDesc(" NOTRACK");
if (!sos.search)
result += resultCharset.execToDesc(" NOSEARCH");
if (!sos.storageManager->requiresCr()
&& sos.records != StorageObjectSpec::find) {
result += resultCharset.execToDesc(' ');
result += resultCharset.execToDesc(FSIParser::recordsName(sos.records));
}
if (sos.codingSystemName) {
if (!sos.zapEof)
result += resultCharset.execToDesc(" NOZAPEOF");
result += resultCharset.execToDesc(" BCTF=");
result += resultCharset.execToDesc(sos.codingSystemName);
}
Boolean needSmcrd = 0;
if (sos.baseId.size() != 0) {
result += resultCharset.execToDesc(" SOIBASE='");
unparseSoi(sos.baseId,
sos.storageManager->idCharset(),
resultCharset,
result,
needSmcrd);
result += resultCharset.execToDesc('\'');
}
StringC tem;
unparseSoi(sos.specId,
sos.storageManager->idCharset(),
resultCharset,
tem,
needSmcrd);
if (needSmcrd)
result += resultCharset.execToDesc(" SMCRD='^'");
result += resultCharset.execToDesc('>');
result += tem;
}
}
Boolean FSIParser::parseAttribute(StringC &token, Boolean &gotValue,
StringC &value)
{
Xchar c = get();
while (isS(c))
c = get();
if (c == -1) {
return 0;
}
token.resize(0);
if (matchChar(c, '>'))
return 1;
if (matchChar(c, '"') || matchChar(c, '\'') || matchChar(c, '='))
return 0;
for (;;) {
token += c;
c = get();
if (c == -1)
return 0;
if (isS(c))
break;
if (matchChar(c, '>') || matchChar(c, '='))
break;
}
while (isS(c))
c = get();
if (c == -1)
return 0;
if (!matchChar(c, '=')) {
unget();
gotValue = 0;
return 1;
}
gotValue = 1;
value.resize(0);
c = get();
while (isS(c))
c = get();
if (matchChar(c, '>') || matchChar(c, '='))
return 0;
if (matchChar(c, '"') || matchChar(c, '\'')) {
Char lit = c;
for (;;) {
Xchar c = get();
if (c == lit)
break;
if (c == -1)
return 0;
if (matchChar(c, '\n'))
;
else if (matchChar(c, '\r') || matchChar(c, '\t'))
value += idCharset_.execToDesc(' ');
else
value += c;
}
uncharref(value);
}
else {
for (;;) {
value += c;
c = get();
if (c == -1)
return 0;
if (isS(c))
break;
if (matchChar(c, '>') || matchChar(c, '=')) {
unget();
break;
}
}
}
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;
}
