MojErr MojDbLevelQuery::getVal(MojDbStorageItem*& itemOut, bool& foundOut)
{
MojObject id;
MojErr err = parseId(id);
MojErrCheck(err);
err = getById(id, itemOut, foundOut);
MojErrCheck(err);
return MojErrNone;
}
MojErr MojDbIsamQuery::getId(MojObject& idOut, MojUInt32& groupOut, bool& foundOut)
{
MojErr err = getKey(groupOut, foundOut);
MojErrCheck(err);
if (foundOut) {
err = parseId(idOut);
MojErrCheck(err);
}
return MojErrNone;
}
/* Parse a type identifer name (schema qualified or not) from spec. spec
* must point to the first char after the % sign, which maybe a double quote.
*
* spec - pointer to typname, just after the '%' or '#'
* schema - buffer to receive schema (PQT_MAXIDLEN bytes)
* typname - buffer to receive typname (PQT_MAXIDLEN bytes)
* flags - a pointer to an int that is set one or more TYPFLAG_xxx
* typpos - 1-based position of spec in specifier string (0 for unknown)
*/
char *
pqt_parsetype(const char *spec, char *schema, char *typname,
int *flags, int typpos)
{
int i;
char *start;
int len=0;
char *s = (char *)spec;
if (!(s = parseId(s, &start, &len, flags, typpos)))
return NULL;
/* not a valid specifer, false positive like "(x % y) = 0" */
if (*flags & TYPFLAG_INVALID)
return s;
*schema = 0;
if (*s == '.')
{
memcpy(schema, start, len);
schema[len] = 0;
if (*flags & TYPFLAG_CASEFOLD)
for (i=0; i < len; i++)
schema[i] = pqt_tolower(schema[i]);
/* now get typname */
if (!(s = parseId(++s, &start, &len, flags, typpos)))
return NULL;
if (*flags & TYPFLAG_INVALID)
return s;
}
memcpy(typname, start, len);
typname[len] = 0;
if (*flags & TYPFLAG_CASEFOLD)
for (i=0; i < len; i++)
schema[i] = pqt_tolower(schema[i]);
return s;
}
void parseProperties(utymap::entities::Element &element, std::uint32_t featureId, const ptree &properties) const {
element.id = 0;
for (const ptree::value_type &property : properties) {
std::uint32_t key = stringTable_.getId(property.first);
if (key==idKey_)
element.id = parseId(property.second.data());
else
element.tags.emplace_back(key, stringTable_.getId(property.second.data()));
}
// NOTE add artificial tag for mapcss processing.
element.tags.emplace_back(featureKey_, featureId);
std::sort(element.tags.begin(), element.tags.end());
}
void RenJS::parseParam(const CString& strParam, RenJS::Node& node)
{
int index = strParam.Find("=");
CString strKey(strParam.Left(index));
CString strValue(strParam.Right(strParam.GetLength() - 1 - index));
if (strKey == "i")
{
parseId(strValue, node);
}
else if (strKey == "p")
{
parseCoordinate(strValue, node);
}
else if (strKey == "m")
{
parseNumber(strValue, node);
}
else if (strKey == "f")
{
parseParent(strValue, node);
}
else if (strKey == "c")
{
parseChildren(strValue, node);
}
else if (strKey == "co")
{
parseComment(strValue, node);
}
else if (strKey == "k")
{
parseBoardText(strValue, node);
}
}
static int yylex(YYSTYPE *lvalp, yyscan_t scanner)
{
const size_t len = scanner->insize;
const unsigned char *in = (const unsigned char*)scanner->in;
unsigned char lookahead;
enum char_class cClass;
scanner->yytext = NULL;
scanner->yylen = 0;
if(scanner->pos == scanner->lastpos) {
if(scanner->last_state == scanner->state) {
cli_dbgmsg(MODULE "infloop detected, skipping character\n");
scanner->pos++;
}
/* its not necesarely an infloop if it changed
* state, and it shouldn't infloop between states */
}
scanner->lastpos = scanner->pos;
scanner->last_state = scanner->state;
while(scanner->pos < scanner->insize) {
switch(scanner->state) {
case Initial:
textbuf_clean(&scanner->buf);
cClass = ctype[in[scanner->pos++]];
switch(cClass) {
case Whitespace:
/* eat whitespace */
continue;
case Slash:
if(scanner->pos < len) {
lookahead = in[scanner->pos];
switch(lookahead) {
case '*':
scanner->state = MultilineComment;
scanner->pos++;
continue;
case '/':
scanner->state = SinglelineComment;
scanner->pos++;
continue;
}
}
--scanner->pos;
return parseOperator(lvalp, scanner);
case Operator:
--scanner->pos;
return parseOperator(lvalp, scanner);
case DQuote:
return parseDQString(lvalp, scanner);
case SQuote:
return parseSQString(lvalp, scanner);
case Digit:
--scanner->pos;
return parseNumber(lvalp, scanner);
case IdStart:
--scanner->pos;
return parseId(lvalp,scanner);
CASE_SPECIAL_CHAR(BracketOpen, "[");
CASE_SPECIAL_CHAR(BracketClose, "]");
CASE_SPECIAL_CHAR(Comma, ",");
CASE_SPECIAL_CHAR(CurlyOpen, "{");
CASE_SPECIAL_CHAR(CurlyClose, "}");
CASE_SPECIAL_CHAR(ParOpen, "(");
CASE_SPECIAL_CHAR(ParClose, ")");
CASE_SPECIAL_CHAR(Dot, ".");
CASE_SPECIAL_CHAR(SemiColon, ";");
case Nop:
continue;
}
break;
case DoubleQString:
return parseString(lvalp, scanner, '"', DoubleQString);
case SingleQString:
return parseString(lvalp, scanner, '\'', SingleQString);
case Identifier:
return parseId(lvalp, scanner);
case MultilineComment:
while(scanner->pos+1 < scanner->insize) {
if(in[scanner->pos] == '*' && in[scanner->pos+1] == '/') {
scanner->state = Initial;
scanner->pos++;
break;
}
scanner->pos++;
}
scanner->pos++;
break;
case Number:
return parseNumber(lvalp, scanner);
case SinglelineComment:
while(scanner->pos < scanner->insize) {
/* htmlnorm converts \n to space, so
* stop on space too */
if(in[scanner->pos] == '\n' || in[scanner->pos] == ' ')
break;
scanner->pos++;
}
scanner->state = Initial;
break;
default:
assert(0 && "Not reached");
}
}
return 0;
}
bool GoogleCalHandler::endElement( const QString & namespaceURI, const QString & localName, const QString & qName )
{
Q_UNUSED(namespaceURI);
Q_UNUSED(localName);
if (ignoreDepth) {
ignoreDepth--;
Q_ASSERT(ignoreDepth >= 0);
return true;
}
Element t = token(qName);
switch(t) {
case Entry:
if (removeCurrentAppointment) {
mRemoved.append(lastAppointment.uid());
removeCurrentAppointment = false;
} else {
mAppointments.append(lastAppointment);
}
lastAppointment = QAppointment();
state = FeedState;
break;
case Feed:
state = StartState;
case Title:
if (state == FeedState)
mName = lastText;
else
lastAppointment.setDescription(lastText);
break;
case Content:
lastAppointment.setNotes(lastText);
break;
case Recurrence:
{
// this is the MAIN TODO, seeing as once this works,
/*
iCal format, is not compatible with vcard parsing.
however it may be similar enough that we can still use existing vcard
parser.
NOTE: RRULE format is different in iCal to vCard
*/
/* Example RRULE text from recurrence section.
can be given instead of when
e.g.
DTSTART;TZID=Australia/Brisbane:20060615T113000
DURATION:PT1800S
RRULE:FREQ=WEEKLY;INTERVAL=2;BYDAY=TH
BEGIN:VTIMEZONE
TZID:Australia/Brisbane
X-LIC-LOCATION:Australia/Brisbane
BEGIN:STANDARD
TZOFFSETFROM:+1000
TZOFFSETTO:+1000
TZNAME:EST
DTSTART:19700101T000000
END:STANDARD
END:VTIMEZONE
*/
// pad out data to make it look like a vcal and get through our parser
// qappointment also has some special ical handling in it.
QByteArray data = "BEGIN:VCALENDAR\r\nVERSION:1.0\r\nBEGIN:VEVENT\r\n"
+ lastText.toUtf8() + "END:VEVENT\r\nEND:VCALENDAR\r\n";
QList<QAppointment> result = QAppointment::readVCalendarData(data.constData(), data.length());
if (result.count() > 0) {
QAppointment a = result[0];
lastAppointment.setStart(a.start());
lastAppointment.setEnd(a.end());
lastAppointment.setRepeatRule(a.repeatRule());
lastAppointment.setFrequency(a.frequency());
lastAppointment.setRepeatUntil(a.repeatUntil());
lastAppointment.setWeekFlags(a.weekFlags());
}
}
break;
case Id:
{
QUniqueId u = parseId(lastText + mIdContext);
lastAppointment.setUid(u);
// a lot more redundency in a google id.
lastAppointment.setCustomField("GoogleId", lastText);
}
break;
case Published:
{
// TODO should support published/updated fields natively in PimRecords?
QDateTime dt = parseDateTime(lastText, QTimeZone::utc());
lastAppointment.setCustomField("GooglePublished", dt.toString(Qt::ISODate));
}
break;
case Updated:
{
QDateTime dt = parseDateTime(lastText, QTimeZone::utc());
lastAppointment.setCustomField("GoogleUpdated", dt.toString(Qt::ISODate));
}
break;
case Category:
case Reminder:
case When:
case Where:
case Status:
break;
case Unrecognized:
break;
}
return true;
}
