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; }