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 CO_ParseDefs (void)
{
int i;
const char *name;
def_t *def;
type_t *type;
int elementCount;
gofs_t offset;
type = PR_ParseType();
if (type == &type_union)
{
if (pr_scope)
{
PR_ParseError("unions must be global");
}
ParseUnion();
return;
}
if (pr_scope && (type->type == ev_field || type->type == ev_function))
{
PR_ParseError("fields and functions must be global");
}
do
{
name = PR_ParseName();
if (TK_CHECK(TK_LPAREN))
{
ParseCStyleFunctionDef(name, type);
return;
}
elementCount = 0;
if (TK_CHECK(TK_LBRACKET))
{
def = GetArrayDef(name, type, &elementCount);
}
else
{
def = PR_GetDef(type, name, pr_scope, true);
}
// Check for initialization
if (TK_CHECK(TK_ASSIGN))
{
if (def->initialized)
{
PR_ParseError("'%s' : redefinition", name);
}
if (type->type == ev_field)
{
PR_ParseError("fields cannot be initialized");
}
if (elementCount != 0)
{
LX_Require("{");
i = 0;
offset = def->ofs;
do
{
if (pr_token_type != tt_immediate)
{
PR_ParseError("immediate type required for %s", name);
}
if (pr_immediate_type->type != type->type)
{
PR_ParseError("wrong immediate type for %s", name);
}
memcpy(pr_globals+offset, &pr_immediate, 4*type_size[pr_immediate_type->type]);
offset += type_size[pr_immediate_type->type];
i++;
LX_Fetch();
} while (TK_CHECK(TK_COMMA));
LX_Require("}");
if (i != elementCount)
{
PR_ParseError("element count mismatch in array"
" initialization");
}
def->initialized = 1;
continue;
}
else if (type->type == ev_function)
{
ParseFunctionDef(def, type);
continue;
}
else if (pr_immediate_type != type)
{
PR_ParseError("wrong immediate type for %s", name);
}
def->initialized = 1;
memcpy(pr_globals+def->ofs, &pr_immediate, 4*type_size[pr_immediate_type->type]);
LX_Fetch();
}
else if (elementCount != 0 && type->type != ev_field)
{
memset(pr_globals+def->ofs, 0, elementCount*4*type_size[type->type]);
def->initialized = 1;
}
} while (TK_CHECK(TK_COMMA));
LX_Require(";");
}
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;
}
