void XSDParser::ParseContent(DTDAttribute& att)
{
TToken tok;
for ( tok=GetNextToken(); tok != K_ENDOFTAG; tok=GetNextToken()) {
switch (tok) {
case T_EOF:
return;
case K_ENUMERATION:
ParseEnumeration(att);
break;
case K_EXTENSION:
ParseExtension(att);
break;
case K_RESTRICTION:
ParseRestriction(att);
break;
case K_ANNOTATION:
SetCommentsIfEmpty(&(att.Comments()));
ParseAnnotation();
break;
case K_UNION:
ParseUnion(att);
break;
case K_LIST:
ParseList(att);
break;
default:
tok = GetRawAttributeSet();
if (tok == K_CLOSING) {
ParseContent(att);
}
break;
}
}
}
void IcecastFetcher::handleJobFinished (int id)
{
if (id != JobID_)
return;
ParseList ();
checkDelete (id);
}
BoxPhysicsComponent::BoxPhysicsComponent(const XmlNode & node)
{
node.ValidateAttributes("halfExtents","");
std::string halfExtentString = GetAttribute<std::string>(node, "halfExtents", "1,1,1");
std::vector<F32> values;
ParseList(halfExtentString, ',', values);
m_HalfExtentVector = Vector3<F32>(values.data());
}
/*
** Searches for News line until buffer fills up or a CRLF or LF is found
*/
PRIVATE int HTNewsList_put_block (HTStream * me, const char * b, int l)
{
while (l-- > 0) {
if (me->state == EOL_FCR) {
if (*b == LF && me->buflen) {
if (!me->junk) {
*(me->buffer+me->buflen) = '\0';
me->group ? ParseGroup(me->request, me->dir, me->buffer) :
ParseList(me->dir, me->buffer);
} else
me->junk = NO; /* back to normal */
}
me->buflen = 0;
me->state = EOL_BEGIN;
} else if (*b == CR) {
me->state = EOL_FCR;
} else if (*b == LF && me->buflen) {
if (!me->junk) {
*(me->buffer+me->buflen) = '\0';
me->group ? ParseGroup(me->request, me->dir, me->buffer) :
ParseList(me->dir, me->buffer);
} else
me->junk = NO; /* back to normal */
me->buflen = 0;
me->state = EOL_BEGIN;
} else {
*(me->buffer+me->buflen++) = *b;
if (me->buflen >= MAX_NEWS_LINE) {
HTTRACE(PROT_TRACE, "News Dir.... Line too long - chopped\n");
*(me->buffer+me->buflen) = '\0';
me->group ? ParseGroup(me->request, me->dir, me->buffer) :
ParseList(me->dir, me->buffer);
me->buflen = 0;
me->junk = YES;
}
}
b++;
}
return HT_OK;
}
void Properties::CreateTree(QTreeWidgetItem* node, const QVariant& v) {
switch (v.type()) {
case QMetaType::QVariantMap:
ParseIterable(node, v.toMap());
break;
case QMetaType::QVariantHash:
ParseIterable(node, v.toHash());
break;
case QMetaType::QVariantList:
ParseList(node, v.toList());
break;
default:
if (node)
node->setData(1, Qt::DisplayRole, v.toString());
break;
}
}
ExprTree *ClassAdXMLParser::
ParseThing(void)
{
ExprTree *tree;
XMLLexer::Token token;
tree = NULL;
lexer.PeekToken(&token);
if (token.token_type == XMLLexer::tokenType_Tag) {
switch (token.tag_id) {
case XMLLexer::tagID_ClassAd:
tree = ParseClassAd();
break;
case XMLLexer::tagID_List:
tree = ParseList();
break;
case XMLLexer::tagID_Integer:
case XMLLexer::tagID_Real:
case XMLLexer::tagID_String:
tree = ParseNumberOrString(token.tag_id);
break;
case XMLLexer::tagID_Bool:
tree = ParseBool();
break;
case XMLLexer::tagID_Undefined:
case XMLLexer::tagID_Error:
tree = ParseUndefinedOrError(token.tag_id);
break;
case XMLLexer::tagID_AbsoluteTime:
tree = ParseAbsTime();
break;
case XMLLexer::tagID_RelativeTime:
tree = ParseRelTime();
break;
case XMLLexer::tagID_Expr:
tree = ParseExpr();
break;
default:
break;
}
}
return tree;
}
void Properties::DisplayProperties(QVariant p) {
// get current property
QString propertyName;
QTreeWidgetItem* item = ui->propertyView->currentItem();
if (item) {
propertyName = item->data(0, Qt::DisplayRole).toString();
}
ui->propertyView->clear();
// only support QVariantMap or QVariantHash at this level
switch (p.type()) {
case QMetaType::QVariantMap:
ParseIterable(NULL, p.toMap());
break;
case QMetaType::QVariantHash:
ParseIterable(NULL, p.toHash());
break;
case QMetaType::QVariantList:
ParseList(NULL, p.toList());
break;
default:
qWarning("Trying to display scalar value as a property");
break;
}
// expand at least the first level
ui->propertyView->expandToDepth(0);
if (propertyName.size() != 0) {
// try to restore the path
QList<QTreeWidgetItem*> items =
ui->propertyView->findItems(propertyName, Qt::MatchRecursive);
if (items.size())
items.front()->setSelected(true);
}
}
bool ParseGeneric ( char *text, const sOptionTableInfo &info, sRejectOptionRMB *option )
{
FUNCTION_ENTRY ( NULL, "ParseGeneric", true );
int dataIndex = 0;
int listIndex = 0;
const char *syntax = info.Syntax;
try {
if ( syntax != NULL ) while ( *syntax ) {
while ( isspace ( *text )) text++;
switch ( *syntax++ ) {
case 'N' :
option->Data [dataIndex++] = ParseNumber ( text );
break;
case 'L' :
option->List [listIndex++] = ParseList ( text, ( *syntax != '\0' ) ? true : false );
break;
}
}
while ( isspace ( *text )) text++;
if (( *text != '\0' ) && ( *text != '#' )) throw "unexpected characters after command";
option->Info = &info;
}
catch ( const char *message ) {
ParseError ( "Syntax error - %s.", message );
return false;
}
return true;
}
bool XSDParser::ParseContent(DTDElement& node, bool extended /*=false*/)
{
DTDElement::EType curr_type;
int emb=0;
bool eatEOT= false;
bool hasContents= false;
TToken tok;
for ( tok=GetNextToken(); ; tok=GetNextToken()) {
emb= node.GetContent().size();
if (tok != T_EOF &&
tok != K_ENDOFTAG &&
tok != K_ANNOTATION) {
hasContents= true;
}
switch (tok) {
case T_EOF:
return hasContents;
case K_ENDOFTAG:
if (eatEOT) {
eatEOT= false;
break;
}
FixEmbeddedNames(node);
return hasContents;
case K_COMPLEXTYPE:
ParseComplexType(node);
break;
case K_SIMPLECONTENT:
ParseSimpleContent(node);
break;
case K_EXTENSION:
ParseExtension(node);
break;
case K_RESTRICTION:
ParseRestriction(node);
break;
case K_ATTRIBUTE:
ParseAttribute(node);
break;
case K_ATTRIBUTEGROUP:
ParseAttributeGroup(node);
break;
case K_ANY:
node.SetTypeIfUnknown(DTDElement::eSequence);
{
string name = CreateTmpEmbeddedName(node.GetName(), emb);
DTDElement& elem = m_MapElement[name];
elem.SetName(name);
elem.SetSourceLine(Lexer().CurrentLine());
elem.SetEmbedded();
elem.SetType(DTDElement::eAny);
elem.SetQualified(node.IsQualified());
ParseAny(elem);
AddElementContent(node,name);
}
break;
case K_SEQUENCE:
emb= node.GetContent().size();
if (emb != 0 && extended) {
node.SetTypeIfUnknown(DTDElement::eSequence);
if (node.GetType() != DTDElement::eSequence) {
ParseError("sequence");
}
tok = GetRawAttributeSet();
eatEOT = true;
break;
}
curr_type = node.GetType();
if (curr_type == DTDElement::eUnknown ||
curr_type == DTDElement::eUnknownGroup ||
(m_ResolveTypes && curr_type == DTDElement::eEmpty)) {
node.SetType(DTDElement::eSequence);
ParseContainer(node);
if (node.GetContent().empty()) {
node.ResetType(curr_type);
}
} else {
string name = CreateTmpEmbeddedName(node.GetName(), emb);
DTDElement& elem = m_MapElement[name];
elem.SetName(name);
elem.SetSourceLine(Lexer().CurrentLine());
elem.SetEmbedded();
elem.SetType(DTDElement::eSequence);
elem.SetQualified(node.IsQualified());
ParseContainer(elem);
AddElementContent(node,name);
}
break;
case K_CHOICE:
curr_type = node.GetType();
if (curr_type == DTDElement::eUnknown ||
curr_type == DTDElement::eUnknownGroup ||
(m_ResolveTypes && curr_type == DTDElement::eEmpty)) {
node.SetType(DTDElement::eChoice);
ParseContainer(node);
if (node.GetContent().empty()) {
node.ResetType(curr_type);
}
} else {
string name = CreateTmpEmbeddedName(node.GetName(), emb);
DTDElement& elem = m_MapElement[name];
elem.SetName(name);
elem.SetSourceLine(Lexer().CurrentLine());
elem.SetEmbedded();
elem.SetType(DTDElement::eChoice);
elem.SetQualified(node.IsQualified());
ParseContainer(elem);
AddElementContent(node,name);
}
break;
case K_SET:
curr_type = node.GetType();
if (curr_type == DTDElement::eUnknown ||
curr_type == DTDElement::eUnknownGroup ||
(m_ResolveTypes && curr_type == DTDElement::eEmpty)) {
node.SetType(DTDElement::eSet);
ParseContainer(node);
if (node.GetContent().empty()) {
node.ResetType(curr_type);
}
} else {
string name = CreateTmpEmbeddedName(node.GetName(), emb);
DTDElement& elem = m_MapElement[name];
elem.SetName(name);
elem.SetSourceLine(Lexer().CurrentLine());
elem.SetEmbedded();
elem.SetType(DTDElement::eSet);
elem.SetQualified(node.IsQualified());
ParseContainer(elem);
AddElementContent(node,name);
}
break;
case K_ELEMENT:
{
string name = ParseElementContent(&node,emb);
AddElementContent(node,name);
}
break;
case K_GROUP:
{
string name = ParseGroup(&node,emb);
AddElementContent(node,name);
}
break;
case K_ANNOTATION:
SetCommentsIfEmpty(&(node.Comments()));
ParseAnnotation();
break;
case K_UNION:
ParseUnion(node);
break;
case K_LIST:
ParseList(node);
break;
default:
for ( tok = GetNextToken(); tok == K_ATTPAIR || tok == K_XMLNS; tok = GetNextToken())
;
if (tok == K_CLOSING) {
ParseContent(node);
}
break;
}
}
FixEmbeddedNames(node);
return hasContents;
}
bool ConfigurationSection::ReadList(const char* name, char delimiter, std::vector<std::string>& result) const
{
std::string s;
return ReadValue(name, s) && ParseList(s, delimiter, result);
}
/* Parse the next expression */
VyParseTree* Parse(){
/* Check that we have not reached the end of the input stream; if so, return null */
if(!MoreTokensExist()){
return NULL;
}
/* Get the next token */
VyToken* next = GetNextToken();
/* It's type is used to determine how to continue parsing */
int tokType = next->type;
/* Store the result of parsing before returning it */
VyParseTree* expr;
/* If it starts with a parenthesis, parse it as a list */
if(tokType == OPAREN){
expr = ParseList();
}
/* If it begins with a quote, then parse whatever is next and quote it */
else if(tokType == QUOTE){
expr = ParseQuoted();
}
/* Parse a substitution */
else if(tokType == DOLLAR){
expr = ParseSubstitution();
}
/* Parse a splicing substitution */
else if(tokType == DOLLARAT){
expr = ParseSpliceSubstitution();
}
/* Parse a bracketed list */
else if(tokType == OBRACKET){
expr = ParseBracketedList();
}
/* Parse an infix list (curly braces) */
else if(tokType == OCURLY){
expr = ParseCurlyList();
}
/* If it is a number, identifier, or string then make a parse tree out of the token */
else if(tokType == IDENT){
VyParseTree* ident = MakeIdent();
SetStrData(ident, next->data);
expr = ident;
}
else if(tokType == NUM){
expr = ParseNumberFromToken(next);
}
else if(tokType == STRING){
VyParseTree* str = MakeString();
SetStrData(str,next->data);
expr = str;
}
/* Unexpected end of list */
else if(tokType == CPAREN || tokType == CBRACKET || tokType == CCURLY){
VyParseTree* err = ParseError("Unexpected end of list");
SetPosition(err, next->pos);
return err;
}
/* If there is no expression before a :, then the token type will be COLON
* Instead of dying, add an error */
else if(tokType == COLON){
VyParseTree* error = ParseError("Reference lacking instance");
SetPosition(error, next->pos);
return error;
}
/* Handle object references: Check whether the next token is a colon.
* If so, then use the previously parsed expression (expr) and another
* expression gotten from Parse() to create a reference node */
VyToken* lookAhead = GetNextToken();
if(lookAhead != NULL /* Make sure that the token list didn't end before looking at the type */
&& lookAhead->type == COLON){
VyParseTree* obj = expr;
VyParseTree* ref = Parse();
/* Check for validity */
if(ref == NULL){
expr = Reference(obj, ParseError("Incomplete reference."));
}else{
expr = Reference(obj, ref);
}
}
else{
/* Backtrack one token to make up for the lookahead */
if(lookAhead != NULL) BacktrackToken();
}
/* Set the position of the current expression */
SetPosition(expr, next->pos);
/* If the tree is an object reference, set the position of
* the first part (obj), because it wasn't gotten through a full Parse() call*/
if(expr->type == TREE_REF){
SetPosition(GetObj(expr), next->pos);
}
return expr;
}
