void XSDParser::ParseEnumeration(DTDAttribute& att) // enumeration // http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/datatypes.html#rf-enumeration // actual value // http://www.w3.org/TR/2004/REC-xmlschema-1-20041028/structures.html#key-vv { TToken tok = GetRawAttributeSet(); att.SetType(DTDAttribute::eEnum); int id = 0; if (GetAttribute("intvalue")) { id = NStr::StringToInt(m_Value); att.SetType(DTDAttribute::eIntEnum); } if (GetAttribute("value")) { string v(m_ValuePrefix); if (!v.empty()) { v += ':'; } v += m_Value; NStr::TruncateSpacesInPlace(v); att.AddEnumValue(v, Lexer().CurrentLine(), id); } if (tok == K_CLOSING) { ParseContent(att); } }
void XSDParser::ParseSimpleContent(DTDElement& node) { TToken tok = GetRawAttributeSet(); if (tok == K_CLOSING) { ParseContent(node); } }
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; } } }
string XSDParser::ParseGroup(DTDElement* owner, int emb) { string name; TToken tok = GetRawAttributeSet(); if (GetAttribute("ref")) { string id = CreateEntityId(m_Value,DTDEntity::eGroup); name = CreateTmpEmbeddedName(owner->GetName(), emb); DTDElement& node = m_MapElement[name]; node.SetEmbedded(); node.SetName(m_Value); node.SetOccurrence( ParseMinOccurs( node.GetOccurrence())); node.SetOccurrence( ParseMaxOccurs( node.GetOccurrence())); node.SetQualified(owner->IsQualified()); SetCommentsIfEmpty(&(node.Comments())); if (m_ResolveTypes) { if (m_MapEntity.find(id) != m_MapEntity.end()) { PushEntityLexer(id); ParseGroupRef(node); } else { ParseError("Unresolved entity", id.c_str()); } } else { node.SetTypeName(node.GetName()); node.SetType(DTDElement::eUnknownGroup); Lexer().FlushCommentsTo(node.Comments()); } } if (tok == K_CLOSING) { ParseContent(m_MapElement[name]); } m_ExpectLastComment = true; return name; }
void XSDParser::ParseContainer(DTDElement& node) { TToken tok = GetRawAttributeSet(); m_ExpectLastComment = true; node.SetOccurrence( ParseMinOccurs( node.GetOccurrence())); node.SetOccurrence( ParseMaxOccurs( node.GetOccurrence())); if (tok == K_CLOSING) { ParseContent(node); } }
void XSDParser::ParseAttributeGroupRef(DTDElement& node) { if (GetNextToken() != K_ATTRIBUTEGROUP) { ParseError("attributeGroup"); } if (GetRawAttributeSet() == K_CLOSING) { ParseContent(node); } PopEntityLexer(); }
void XSDParser::ParseGroupRef(DTDElement& node) { if (GetNextToken() != K_GROUP) { ParseError("group"); } TToken tok = GetRawAttributeSet(); if (tok == K_CLOSING) { ParseContent(node); } PopEntityLexer(); }
void XSDParser::ParseComplexType(DTDElement& node) { TToken tok = GetRawAttributeSet(); if (GetAttribute("mixed")) { if (IsValue("true")) { string name(s_SpecialName); AddElementContent(node,name); } } if (tok == K_CLOSING) { ParseContent(node); } }
void XSDParser::ParseRestriction(DTDAttribute& att) { TToken tok = GetRawAttributeSet(); if (GetAttribute("base")) { if (!DefineAttributeType(att)) { if (m_ResolveTypes) { string id = CreateEntityId(m_Value,DTDEntity::eType); if (m_MapEntity.find(id) != m_MapEntity.end()) { PushEntityLexer(id); ParseContent(att); } else { ParseError("Unresolved entity", id.c_str()); } } else { att.SetTypeName(m_Value); } } } if (tok == K_CLOSING) { ParseContent(att); } }
void XSDParser::ParseRestriction(DTDElement& node) { TToken tok = GetRawAttributeSet(); bool extended=false; if (GetAttribute("base")) { if (!DefineElementType(node)) { string id = CreateEntityId(m_Value,DTDEntity::eType); if (m_ResolveTypes) { if (m_MapEntity.find(id) != m_MapEntity.end()) { PushEntityLexer(id); ParseContent(node); extended=true; } else { ParseError("Unresolved entity", id.c_str()); } } else { node.SetTypeName(m_Value); } } } if (tok == K_CLOSING) { ParseContent(node,extended); } }
void XSDParser::ParseAttribute(DTDElement& node) { DTDAttribute a; node.AddAttribute(a); DTDAttribute& att = node.GetNonconstAttributes().back(); att.SetSourceLine(Lexer().CurrentLine()); SetCommentsIfEmpty(&(att.Comments())); bool ref=false, named_type=false; bool qualified = m_AttributeFormDefault; TToken tok = GetRawAttributeSet(); if (GetAttribute("ref")) { att.SetName(m_Value); ref=true; } if (GetAttribute("name")) { att.SetName(m_Value); } if (GetAttribute("type")) { if (!DefineAttributeType(att)) { att.SetTypeName(m_Value); named_type = true; } } if (GetAttribute("use")) { if (IsValue("required")) { att.SetValueType(DTDAttribute::eRequired); } else if (IsValue("optional")) { att.SetValueType(DTDAttribute::eImplied); } else if (IsValue("prohibited")) { att.SetValueType(DTDAttribute::eProhibited); } } if (GetAttribute("default")) { att.SetValue(m_Value); } if (GetAttribute("form")) { qualified = IsValue("qualified"); } att.SetQualified(qualified); if (tok == K_CLOSING) { ParseContent(att); } if (!ref && !named_type) { att.SetTypeIfUnknown(DTDAttribute::eString); } m_ExpectLastComment = true; }
XDAS_Int32 readparamfile(FILE * fname , int baseParamsOnly) { XDAS_Int8 *FileBuffer = NULL ; XDAS_Int32 retVal ; //read the content in a buffer FileBuffer = GetConfigFileContent(fname); if(FileBuffer) { retVal = ParseContent(FileBuffer,strlen(FileBuffer),baseParamsOnly); return retVal ; } else return -1; }
XDAS_Int32 readparamfile(FILE * fname) { XDAS_Int8 *FileBuffer = NULL ; XDAS_Int32 retVal ; /* Read entire content in a buffer */ FileBuffer = GetConfigFileContent(fname); /* if the buffer address is NULL then return error */ if(FileBuffer) { /* Parse every string into items and group them into triplets. * Decode these ordered triplets into correspondign indices in the global * Token Map arrray provided by the user. */ retVal = ParseContent(FileBuffer, strlen((xdc_Char *)FileBuffer)); return retVal ; } else return -1; }
void XSDParser::ParseAny(DTDElement& node) { TToken tok = GetRawAttributeSet(); #if 0 if (GetAttribute("processContents")) { if (!IsValue("lax") && !IsValue("skip")) { ParseError("lax or skip"); } } #endif node.SetOccurrence( ParseMinOccurs( node.GetOccurrence())); node.SetOccurrence( ParseMaxOccurs( node.GetOccurrence())); if (GetAttribute("namespace")) { node.SetNamespaceName(m_Value); } SetCommentsIfEmpty(&(node.Comments())); if (tok == K_CLOSING) { ParseContent(node); } m_ExpectLastComment = true; }
void XSDParser::ParseAttributeGroup(DTDElement& node) { TToken tok = GetRawAttributeSet(); if (GetAttribute("ref")) { if (m_ResolveTypes) { string id = CreateEntityId(m_Value,DTDEntity::eAttGroup); if (m_MapEntity.find(id) != m_MapEntity.end()) { PushEntityLexer(id); ParseAttributeGroupRef(node); } else { ParseError("Unresolved entity", id.c_str()); } } else { DTDAttribute a; a.SetType(DTDAttribute::eUnknownGroup); a.SetTypeName(m_Value); Lexer().FlushCommentsTo(node.AttribComments()); node.AddAttribute(a); } } if (tok == K_CLOSING) { ParseContent(node); } }
string XSDParser::ParseAttributeContent() { TToken tok = GetRawAttributeSet(); string name; if (GetAttribute("ref")) { name = m_Value; } if (GetAttribute("name")) { name = m_Value; m_MapAttribute[name].SetName(name); SetCommentsIfEmpty(&(m_MapAttribute[name].Comments())); } if (GetAttribute("type")) { if (!DefineAttributeType(m_MapAttribute[name])) { m_MapAttribute[name].SetTypeName(m_Value); } } m_MapAttribute[name].SetQualified(true); if (tok == K_CLOSING) { ParseContent(m_MapAttribute[name]); } m_ExpectLastComment = true; return name; }
/*! *********************************************************************** * \brief * Parse the command line parameters and read the config files. * \param ac * number of command line parameters * \param av * command line parameters *********************************************************************** */ void Configure (int ac, char *av[]) { char *content; int CLcount, ContentLen, NumberParams; char *filename=DEFAULTCONFIGFILENAME; memset (&configinput, 0, sizeof (InputParameters)); //Set default parameters. printf ("Setting Default Parameters...\n"); InitEncoderParams(); // Process default config file CLcount = 1; if (ac==2) { if (0 == strncmp (av[1], "-h", 2)) { JMHelpExit(); } } if (ac>=3) { if (0 == strncmp (av[1], "-d", 2)) { filename=av[2]; CLcount = 3; } if (0 == strncmp (av[1], "-h", 2)) { JMHelpExit(); } } printf ("Parsing Configfile %s", filename); content = GetConfigFileContent (filename); if (NULL==content) error (errortext, 300); ParseContent (content, strlen(content)); printf ("\n"); free (content); // Parse the command line while (CLcount < ac) { if (0 == strncmp (av[CLcount], "-h", 2)) { JMHelpExit(); } if (0 == strncmp (av[CLcount], "-f", 2)) // A file parameter? { content = GetConfigFileContent (av[CLcount+1]); if (NULL==content) error (errortext, 300); printf ("Parsing Configfile %s", av[CLcount+1]); ParseContent (content, strlen (content)); printf ("\n"); free (content); CLcount += 2; } else { if (0 == strncmp (av[CLcount], "-p", 2)) // A config change? { // Collect all data until next parameter (starting with -<x> (x is any character)), // put it into content, and parse content. CLcount++; ContentLen = 0; NumberParams = CLcount; // determine the necessary size for content while (NumberParams < ac && av[NumberParams][0] != '-') ContentLen += strlen (av[NumberParams++]); // Space for all the strings ContentLen += 1000; // Additional 1000 bytes for spaces and \0s if ((content = malloc (ContentLen))==NULL) no_mem_exit("Configure: content");; content[0] = '\0'; // concatenate all parameters identified before while (CLcount < NumberParams) { char *source = &av[CLcount][0]; char *destin = &content[strlen (content)]; while (*source != '\0') { if (*source == '=') // The Parser expects whitespace before and after '=' { *destin++=' '; *destin++='='; *destin++=' '; // Hence make sure we add it } else *destin++=*source; source++; } *destin = '\0'; CLcount++; } printf ("Parsing command line string '%s'", content); ParseContent (content, strlen(content)); free (content); printf ("\n"); } else { snprintf (errortext, ET_SIZE, "Error in command line, ac %d, around string '%s', missing -f or -p parameters?", CLcount, av[CLcount]); error (errortext, 300); } } } printf ("\n"); PatchInp(); if (input->DisplayEncParams) DisplayEncoderParams(); }
void XSDParser::ProcessNamedTypes(void) { m_ResolveTypes = true; set<string> processed; bool found; do { found = false; map<string,DTDElement>::iterator i; for (i = m_MapElement.begin(); i != m_MapElement.end(); ++i) { DTDElement& node = i->second; if (!node.GetTypeName().empty()) { if ( node.GetType() == DTDElement::eUnknown) { found = true; // in rare cases of recursive type definition this node type can already be defined map<string,DTDElement>::iterator j; for (j = m_MapElement.begin(); j != m_MapElement.end(); ++j) { if (j->second.GetName() == node.GetName() && j->second.GetTypeName() == node.GetTypeName() && j->second.GetType() != DTDElement::eUnknown) { m_MapElement[i->first] = j->second; break; } } if (j != m_MapElement.end()) { break; } PushEntityLexer(CreateEntityId(node.GetTypeName(),DTDEntity::eType)); bool elementForm = m_ElementFormDefault; ParseContent(node); node.SetTypeIfUnknown(DTDElement::eEmpty); // Make local elements defined by means of global types global. // In fact, this is incorrect; also, in case of unqualified form default we must keep // such elements embedded, otherwise they will be treated as ns-qualified. // for us, this trick solves the problem of recursive type definitions: // local element A contains local element B, which contains local element A, etc. // the way it is now, code generator will simply crash. // The better solution would be to modify C++ code generation, of course. // as of 24may11, the code generator is modified. // BUT, the mistake is already made; we want to provide backward compatibility now. if (node.IsNamed() && node.IsEmbedded() && elementForm) { map<string,DTDElement>::iterator k; for (k = m_MapElement.begin(); k != m_MapElement.end(); ++k) { if (!k->second.IsEmbedded() && k->second.IsNamed() && k->second.GetName() == node.GetName() && k->second.GetTypeName() != node.GetTypeName()) { break; } } if (k == m_MapElement.end()) { node.SetEmbedded(false); } } } else if ( node.GetType() == DTDElement::eUnknownGroup) { found = true; PushEntityLexer(CreateEntityId(node.GetTypeName(),DTDEntity::eGroup)); ParseGroupRef(node); if (node.GetType() == DTDElement::eUnknownGroup) { node.SetType(DTDElement::eEmpty); } } else if (processed.find(i->second.GetName()) == processed.end()) { if (node.GetType() < DTDElement::eWsdlService) { PushEntityLexer(CreateEntityId(node.GetTypeName(),DTDEntity::eType)); ParseContent(node); } } processed.insert(i->second.GetName()); } } } while (found); do { found = false; map<string,DTDElement>::iterator i; for (i = m_MapElement.begin(); i != m_MapElement.end(); ++i) { DTDElement& node = i->second; if (node.HasAttributes()) { list<DTDAttribute>& atts = node.GetNonconstAttributes(); list<DTDAttribute>::iterator a; for (a = atts.begin(); a != atts.end(); ++a) { if (a->GetType() == DTDAttribute::eUnknown && a->GetTypeName().empty() && m_MapAttribute.find(a->GetName()) != m_MapAttribute.end()) { found = true; a->Merge(m_MapAttribute[a->GetName()]); } } } } } while (found); do { found = false; map<string,DTDElement>::iterator i; for (i = m_MapElement.begin(); i != m_MapElement.end(); ++i) { DTDElement& node = i->second; if (node.HasAttributes()) { list<DTDAttribute>& atts = node.GetNonconstAttributes(); list<DTDAttribute>::iterator a; for (a = atts.begin(); a != atts.end(); ++a) { if (!a->GetTypeName().empty()) { if ( a->GetType() == DTDAttribute::eUnknown) { found = true; PushEntityLexer(CreateEntityId(a->GetTypeName(),DTDEntity::eType)); ParseContent(*a); if (a->GetType() == DTDAttribute::eUnknown) { a->SetType(DTDAttribute::eString); } } else if ( a->GetType() == DTDAttribute::eUnknownGroup) { found = true; PushEntityLexer(CreateEntityId(a->GetTypeName(),DTDEntity::eAttGroup)); atts.erase(a); ParseAttributeGroupRef(node); break; } } } } } } while (found); { map<string,DTDElement>::iterator i; for (i = m_MapElement.begin(); i != m_MapElement.end(); ++i) { i->second.MergeAttributes(); } } m_ResolveTypes = false; }
string XSDParser::ParseElementContent(DTDElement* owner, int emb) { TToken tok; string name, value; bool ref=false, named_type=false; bool qualified = m_ElementFormDefault; int line = Lexer().CurrentLine(); tok = GetRawAttributeSet(); if (GetAttribute("ref")) { if (IsValue("schema") && GetElementNamespace(m_ValuePrefix) == eSchemaNamespace) { name = CreateTmpEmbeddedName(owner->GetName(), emb); DTDElement& elem = m_MapElement[name]; elem.SetName(m_Value); elem.SetSourceLine(Lexer().CurrentLine()); elem.SetEmbedded(); elem.SetType(DTDElement::eAny); ref=false; } else { name = m_Value; ref=true; } } if (GetAttribute("name")) { ref=false; name = m_Value; if (owner) { name = CreateTmpEmbeddedName(owner->GetName(), emb); m_MapElement[name].SetEmbedded(); m_MapElement[name].SetNamed(); } m_MapElement[name].SetName(m_Value); m_MapElement[name].SetSourceLine(line); SetCommentsIfEmpty(&(m_MapElement[name].Comments())); } if (GetAttribute("type")) { if (!DefineElementType(m_MapElement[name])) { m_MapElement[name].SetTypeName(m_Value); named_type = true; } } if (owner && GetAttribute("form")) { qualified = IsValue("qualified"); } if (GetAttribute("default")) { m_MapElement[name].SetDefault(m_Value); } if (owner && !name.empty()) { owner->SetOccurrence(name, ParseMinOccurs( owner->GetOccurrence(name))); owner->SetOccurrence(name, ParseMaxOccurs( owner->GetOccurrence(name))); } if (tok != K_CLOSING && tok != K_ENDOFTAG) { ParseError("endoftag"); } m_MapElement[name].SetNamespaceName(m_TargetNamespace); m_MapElement[name].SetQualified(qualified); bool hasContents = false; if (tok == K_CLOSING) { hasContents = ParseContent(m_MapElement[name]); } m_ExpectLastComment = true; if (!ref && !named_type) { m_MapElement[name].SetTypeIfUnknown( hasContents ? DTDElement::eEmpty : DTDElement::eString); } return name; }
/* ************************************************************************* * Function:Parse the command line parameters and read the config files. * Input: ac number of command line parameters av command line parameters * Output: * Return: * Attention: ************************************************************************* */ void c_avs_enc::Configure (char *av) { char *content; Map[0].TokenName = "GOPLength"; Map[1].TokenName = "FramesToBeEncoded"; Map[2].TokenName = "QPFirstFrame"; Map[3].TokenName = "QPRemainingFrame"; Map[4].TokenName = "UseHadamard"; Map[5].TokenName = "SearchRange"; Map[6].TokenName = "NumberReferenceFrames"; Map[7].TokenName = "SourceWidth"; Map[8].TokenName = "SourceHeight"; Map[9].TokenName = "InputFile"; Map[10].TokenName = "InputHeaderLength"; Map[11].TokenName = "OutputFile"; Map[12].TokenName = "ReconFile"; Map[13].TokenName = "TraceFile"; Map[14].TokenName = "NumberBFrames"; Map[15].TokenName = "QPBPicture"; Map[16].TokenName = "InterSearch16x16"; Map[17].TokenName = "InterSearch16x8"; Map[18].TokenName = "InterSearch8x16"; Map[19].TokenName = "InterSearch8x8"; Map[20].TokenName = "RDOptimization"; Map[21].TokenName = "InterlaceCodingOption"; Map[22].TokenName = "LoopFilterDisable"; Map[23].TokenName = "LoopFilterParameter"; Map[24].TokenName = "LoopFilterAlphaOffset"; Map[25].TokenName = "LoopFilterBetaOffset"; Map[26].TokenName = "Progressive_frame"; Map[27].TokenName = "Dct_Adaptive_Flag"; Map[28].TokenName = "NumberOfRowsInSlice"; Map[29].TokenName = "SliceParameter"; Map[30].TokenName = "WeightEnable"; Map[31].TokenName = "FrameRate"; Map[32].TokenName = "ChromaFormat"; Map[33].TokenName = "RateControlEnable"; Map[34].TokenName = "Bitrate"; Map[35].TokenName = "InitialQP"; Map[36].TokenName = "BasicUnit"; Map[37].TokenName = "ChannelType"; Map[38].TokenName = NULL; Map[0].Place = &configinput.GopLength; Map[1].Place = &configinput.no_frames; Map[2].Place = &configinput.qp0; Map[3].Place = &configinput.qpN; Map[4].Place = &configinput.hadamard; Map[5].Place = &configinput.search_range; Map[6].Place = &configinput.no_multpred; Map[7].Place = &configinput.img_width; Map[8].Place = &configinput.img_height; Map[9].Place = &configinput.infile; Map[10].Place = &configinput.infile_header; Map[11].Place = &configinput.outfile; Map[12].Place = &configinput.ReconFile; Map[13].Place = &configinput.TraceFile; Map[14].Place = &configinput.successive_Bframe; Map[15].Place = &configinput.qpB; Map[16].Place = &configinput.InterSearch16x16; Map[17].Place = &configinput.InterSearch16x8 ; Map[18].Place = &configinput.InterSearch8x16; Map[19].Place = &configinput.InterSearch8x8 ; Map[20].Place = &configinput.rdopt; Map[21].Place = &configinput.InterlaceCodingOption; Map[22].Place = &configinput.loop_filter_disable; Map[23].Place = &configinput.loop_filter_parameter_flag; Map[24].Place = &configinput.alpha_c_offset; Map[25].Place = &configinput.beta_offset; Map[26].Place = &configinput.progressive_frame; Map[27].Place = &configinput.dct_adaptive_flag; Map[28].Place = &configinput.slice_row_nr; Map[29].Place = &configinput.slice_parameter; Map[30].Place = &configinput.picture_weighting_flag; Map[31].Place = &configinput.frame_rate_code; Map[32].Place = &configinput.chroma_format; Map[33].Place = &configinput.RCEnable; Map[34].Place = &configinput.bit_rate; Map[35].Place = &configinput.SeinitialQP; Map[36].Place = &configinput.basicunit; Map[37].Place = &configinput.channel_type; Map[38].Place = NULL; Map[0].Type = 0; Map[1].Type = 0; Map[2].Type = 0; Map[3].Type = 0; Map[4].Type = 0; Map[5].Type = 0; Map[6].Type = 0; Map[7].Type = 0; Map[8].Type = 0; Map[9].Type = 1; Map[10].Type = 0; Map[11].Type = 1; Map[12].Type = 1; Map[13].Type = 1; Map[14].Type = 0; Map[15].Type = 0; Map[16].Type = 0; Map[17].Type = 0; Map[18].Type = 0; Map[19].Type = 0; Map[20].Type = 0; Map[21].Type = 0; Map[22].Type = 0; Map[23].Type = 0; Map[24].Type = 0; Map[25].Type = 0; Map[26].Type = 0; Map[27].Type = 0; Map[28].Type = 0; Map[29].Type = 0; Map[30].Type = 0; Map[31].Type = 0; Map[32].Type = 0; Map[33].Type = 0; Map[34].Type = 0; Map[35].Type = 0; Map[36].Type = 0; Map[37].Type = 0; Map[38].Type = -1; memset (&configinput, 0, sizeof (InputParameters)); // Process default config file // Parse the command line content = GetConfigFileContent (av); printf ("Parsing Configfile %s", av); ParseContent (content, (int_32_t)strlen (content)); printf ("\n"); free (content); printf ("\n"); }
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; }