void xnode::setNodePermissions(int perm)
{
if( perm != R && perm != W && perm != RW)
throw xmlError("Invalid permission.");
if(perm==R)
locked=true;
permissions=perm;
}
void UpdateDialog::setVersionChecker(VersionChecker * versionChecker)
{
if (m_versionChecker != NULL) {
m_versionChecker->stop();
delete m_versionChecker;
}
m_feedbackLabel->setText(tr("Checking..."));
m_versionChecker = versionChecker;
connect(m_versionChecker, SIGNAL(releasesAvailable()), this, SLOT(releasesAvailableSlot()));
connect(m_versionChecker, SIGNAL(xmlError(QXmlStreamReader::Error)), this, SLOT(xmlErrorSlot(QXmlStreamReader::Error)));
connect(m_versionChecker, SIGNAL(httpError(QHttp::Error)), this, SLOT(httpErrorSlot(QHttp::Error)));
m_versionChecker->fetch();
}
float xnode::getFloat() const
{
float val=0.0;
if(value !="")
{
std::istringstream is(value);
is.exceptions(std::ios::failbit);
try
{
is>>val;
}
catch(std::exception& e)
{
std::ostringstream os;
os<<"Float conversion error.";
std::cout << e.what() << std::endl;
throw xmlError(os.str().c_str());
}
}
//---------------------------------------------------------
//Method Name: setValue
//
//Purpose: Set the value of the current node (alternative to writeToNode)
//Precondition: pass a string containing the value
//Postcondition: Returns void
//---------------------------------------------------------
void xnode::setValue(std::string val, bool ignore_perm)
{
if(!locked || ignore_perm)
{
if(val == "?" && use_default_query)
{
node_queried = true;
}
else
{
value=val;
changed=true;
last=value;
}
}
else
{
std::ostringstream os;
os<<"The value of "<<name<<" is is read-only (locked) and can not be updated.";
throw xmlError(os.str().c_str());
}
}
/*
XML recursive descent parser. Return -1 for errors, 0 for EOF and 1 if there is still more data to parse.
*/
static int parseNext(MprXml *xp, int state)
{
MprXmlHandler handler;
MprXmlToken token;
MprBuf *tokBuf;
char *tname, *aname;
int rc;
mprAssert(state >= 0);
tokBuf = xp->tokBuf;
handler = xp->handler;
tname = aname = 0;
rc = 0;
/*
In this parse loop, the state is never assigned EOF or ERR. In such cases we always return EOF or ERR.
*/
while (1) {
token = getXmlToken(xp, state);
if (token == MPR_XMLTOK_TOO_BIG) {
xmlError(xp, "XML token is too big");
return MPR_ERR_WONT_FIT;
}
switch (state) {
case MPR_XML_BEGIN: /* ------------------------------------------ */
/*
Expect to get an element, comment or processing instruction
*/
switch (token) {
case MPR_XMLTOK_EOF:
return 0;
case MPR_XMLTOK_LS:
/*
Recurse to handle the new element, comment etc.
*/
rc = parseNext(xp, MPR_XML_AFTER_LS);
if (rc < 0) {
return rc;
}
break;
default:
xmlError(xp, "Syntax error");
return MPR_ERR_BAD_SYNTAX;
}
break;
case MPR_XML_AFTER_LS: /* ------------------------------------------ */
switch (token) {
case MPR_XMLTOK_COMMENT:
state = MPR_XML_COMMENT;
rc = (*handler)(xp, state, "!--", 0, mprGetBufStart(tokBuf));
if (rc < 0) {
return rc;
}
return 1;
case MPR_XMLTOK_CDATA:
state = MPR_XML_CDATA;
rc = (*handler)(xp, state, "!--", 0, mprGetBufStart(tokBuf));
if (rc < 0) {
return rc;
}
return 1;
case MPR_XMLTOK_INSTRUCTIONS:
/* Just ignore processing instructions */
return 1;
case MPR_XMLTOK_TEXT:
state = MPR_XML_NEW_ELT;
tname = sclone(mprGetBufStart(tokBuf));
if (tname == 0) {
mprAssert(!MPR_ERR_MEMORY);
return MPR_ERR_MEMORY;
}
rc = (*handler)(xp, state, tname, 0, 0);
if (rc < 0) {
return rc;
}
break;
default:
xmlError(xp, "Syntax error");
return MPR_ERR_BAD_SYNTAX;
}
break;
case MPR_XML_NEW_ELT: /* ------------------------------------------ */
/*
We have seen the opening "<element" for a new element and have not yet seen the terminating
">" of the opening element.
*/
switch (token) {
case MPR_XMLTOK_TEXT:
/*
Must be an attribute name
*/
aname = sclone(mprGetBufStart(tokBuf));
token = getXmlToken(xp, state);
if (token != MPR_XMLTOK_EQ) {
xmlError(xp, "Missing assignment for attribute \"%s\"", aname);
return MPR_ERR_BAD_SYNTAX;
}
token = getXmlToken(xp, state);
if (token != MPR_XMLTOK_TEXT) {
xmlError(xp, "Missing value for attribute \"%s\"", aname);
return MPR_ERR_BAD_SYNTAX;
}
state = MPR_XML_NEW_ATT;
rc = (*handler)(xp, state, tname, aname, mprGetBufStart(tokBuf));
if (rc < 0) {
return rc;
}
state = MPR_XML_NEW_ELT;
break;
case MPR_XMLTOK_GR:
/*
This is ">" the termination of the opening element
*/
if (*tname == '\0') {
xmlError(xp, "Missing element name");
return MPR_ERR_BAD_SYNTAX;
}
/*
Tell the user that the opening element is now complete
*/
state = MPR_XML_ELT_DEFINED;
rc = (*handler)(xp, state, tname, 0, 0);
if (rc < 0) {
return rc;
}
state = MPR_XML_ELT_DATA;
break;
case MPR_XMLTOK_SLASH_GR:
/*
If we see a "/>" then this is a solo element
*/
if (*tname == '\0') {
xmlError(xp, "Missing element name");
return MPR_ERR_BAD_SYNTAX;
}
state = MPR_XML_SOLO_ELT_DEFINED;
rc = (*handler)(xp, state, tname, 0, 0);
if (rc < 0) {
return rc;
}
return 1;
default:
xmlError(xp, "Syntax error");
return MPR_ERR_BAD_SYNTAX;
}
break;
case MPR_XML_ELT_DATA: /* -------------------------------------- */
/*
We have seen the full opening element "<name ...>" and now await data or another element.
*/
if (token == MPR_XMLTOK_LS) {
/*
Recurse to handle the new element, comment etc.
*/
rc = parseNext(xp, MPR_XML_AFTER_LS);
if (rc < 0) {
return rc;
}
break;
} else if (token == MPR_XMLTOK_LS_SLASH) {
state = MPR_XML_END_ELT;
break;
} else if (token != MPR_XMLTOK_TEXT) {
return rc;
}
if (mprGetBufLength(tokBuf) > 0) {
/*
Pass the data between the element to the user
*/
rc = (*handler)(xp, state, tname, 0, mprGetBufStart(tokBuf));
if (rc < 0) {
return rc;
}
}
break;
case MPR_XML_END_ELT: /* -------------------------------------- */
if (token != MPR_XMLTOK_TEXT) {
xmlError(xp, "Missing closing element name for \"%s\"", tname);
return MPR_ERR_BAD_SYNTAX;
}
/*
The closing element name must match the opening element name
*/
if (strcmp(tname, mprGetBufStart(tokBuf)) != 0) {
xmlError(xp, "Closing element name \"%s\" does not match on line %d. Opening name \"%s\"",
mprGetBufStart(tokBuf), xp->lineNumber, tname);
return MPR_ERR_BAD_SYNTAX;
}
rc = (*handler)(xp, state, tname, 0, 0);
if (rc < 0) {
return rc;
}
if (getXmlToken(xp, state) != MPR_XMLTOK_GR) {
xmlError(xp, "Syntax error");
return MPR_ERR_BAD_SYNTAX;
}
return 1;
case MPR_XML_EOF: /* ---------------------------------------------- */
return 0;
case MPR_XML_ERR: /* ---------------------------------------------- */
default:
return MPR_ERR;
}
}
mprAssert(0);
}