static int procHost(parseUnion * lvalp, ParserControl * parm)
{
static XmlElement elm[] = {
{NULL}
};
XmlAttr attr[1];
if (tagEquals(parm->xmb, "HOST")) {
if (attrsOk(parm->xmb, elm, attr, "HOST", ZTOK_HOST)) {
lvalp->xtokHost.host = getContent(parm->xmb);
return XTOK_HOST;
}
}
return 0;
}
static int procValueNamedInstance(parseUnion * lvalp, ParserControl * parm)
{
static XmlElement elm[] = {
{NULL}
};
XmlAttr attr[1];
if (tagEquals(parm->xmb, "VALUE.NAMEDINSTANCE")) {
if (attrsOk(parm->xmb, elm, attr, "VALUE.NAMEDINSTANCE",
ZTOK_VALUENAMEDINSTANCE)) {
return XTOK_VALUENAMEDINSTANCE;
}
}
return 0;
}
static int procIRetValue(parseUnion * lvalp, ParserControl * parm)
{
if (tagEquals(parm->xmb, "IRETURNVALUE")) {
static XmlElement elm[] = {
{NULL}
};
XmlAttr attr[0];
memset(attr, 0, sizeof(attr));
if (attrsOk(parm->xmb, elm, attr, "IRETURNVALUE", ZTOK_IRETVALUE)) {
return XTOK_IRETVALUE;
}
}
return 0;
}
static int procObjectPath(parseUnion * lvalp, ParserControl * parm)
{
static XmlElement elm[] = {
{NULL}
};
XmlAttr attr[1];
if (tagEquals(parm->xmb, "OBJECTPATH")) {
if (attrsOk(parm->xmb, elm, attr, "OBJECTPATH",
ZTOK_OBJECTPATH)) {
return XTOK_OBJECTPATH;
}
}
return 0;
}
static int procLocalInstancePath(parseUnion * lvalp, ParserControl * parm)
{
static XmlElement elm[] = {
{NULL}
};
XmlAttr attr[1];
if (tagEquals(parm->xmb, "LOCALINSTANCEPATH")) {
if (attrsOk
(parm->xmb, elm, attr, "LOCALINSTANCEPATH",
ZTOK_LOCALINSTANCEPATH)) {
return XTOK_LOCALINSTANCEPATH;
}
}
return 0;
}
static int procSimpleExpReq(parseUnion * lvalp, ParserControl * parm)
{
static XmlElement elm[] = {
{NULL}
};
XmlAttr attr[1];
if (tagEquals(parm->xmb, "SIMPLEEXPREQ")) {
if (attrsOk(parm->xmb, elm, attr, "SIMPLEEXPREQ", ZTOK_SIMPLEEXPREQ))
{
return XTOK_SIMPLEEXPREQ;
}
}
return 0;
}
static int procXml(parseUnion * lvalp, ParserControl * parm)
{
static XmlElement elm[] = { {"version"},
{"encoding"},
{NULL}
};
XmlAttr attr[2];
memset(attr, 0, sizeof(attr));
if (tagEquals(parm->xmb, "?xml")) {
if (attrsOk(parm->xmb, elm, attr, "?xml", ZTOK_XML)) {
return XTOK_XML;
}
}
return 0;
}
static int procLocalNameSpacePath(parseUnion * lvalp, ParserControl * parm)
{
static XmlElement elm[] = {
{NULL}
};
XmlAttr attr[1];
if (tagEquals(parm->xmb, "LOCALNAMESPACEPATH")) {
if (attrsOk
(parm->xmb, elm, attr, "LOCALNAMESPACEPATH",
ZTOK_LOCALNAMESPACEPATH)) {
lvalp->xtokLocalNameSpacePath.value = NULL;
return XTOK_LOCALNAMESPACEPATH;
}
}
return 0;
}
static int procValue(parseUnion * lvalp, ParserControl * parm)
{
static XmlElement elm[] = {
{NULL}
};
XmlAttr attr[1];
if (tagEquals(parm->xmb, "VALUE")) {
char *v;
if (attrsOk(parm->xmb, elm, attr, "VALUE", ZTOK_VALUE)) {
v=getContent(parm->xmb);
lvalp->xtokValue.data.value = v;
return XTOK_VALUE;
}
}
return 0;
}
static int procValueRefArray(parseUnion * lvalp, ParserControl * parm)
{
static XmlElement elm[] = {
{NULL}
};
XmlAttr attr[1];
if (tagEquals(parm->xmb, "VALUE.REFARRAY")) {
if (attrsOk(parm->xmb, elm, attr, "VALUE.REFARRAY",
ZTOK_VALUEARRAY)) {
lvalp->xtokValueRefArray.max = 16;
lvalp->xtokValueRefArray.next = 0;
lvalp->xtokValueRefArray.values = (XtokValueReference*)parser_malloc(parm->heap, (sizeof(XtokValueReference) * lvalp->xtokValueRefArray.max));
return XTOK_VALUEREFARRAY;
}
}
return 0;
}
static int procClassName(parseUnion * lvalp, ParserControl * parm)
{
static XmlElement elm[] = {
{"NAME"},
{NULL}
};
XmlAttr attr[1];
memset(attr, 0, sizeof(attr));
if (tagEquals(parm->xmb, "CLASSNAME")) {
if (attrsOk(parm->xmb, elm, attr, "CLASSNAME", ZTOK_CLASSNAME)) {
lvalp->xtokClassName.value = attr[0].attr;
return XTOK_CLASSNAME;
}
}
return 0;
}
static int procKeyBinding(parseUnion * lvalp, ParserControl * parm)
{
static XmlElement elm[] = {
{"NAME"},
{NULL}
};
XmlAttr attr[1];
memset(attr, 0, sizeof(attr));
if (tagEquals(parm->xmb, "KEYBINDING")) {
if (attrsOk(parm->xmb, elm, attr, "KEYBINDING", ZTOK_KEYBINDING)) {
lvalp->xtokKeyBinding.name = attr[0].attr;
return XTOK_KEYBINDING;
}
}
return 0;
}
static int procCim(parseUnion * lvalp, ParserControl * parm)
{
static XmlElement elm[] = {
{"CIMVERSION"},
{"DTDVERSION"},
{NULL}
};
XmlAttr attr[2];
memset(attr, 0, sizeof(attr));
if (tagEquals(parm->xmb, "CIM")) {
if (attrsOk(parm->xmb, elm, attr, "CIM", ZTOK_CIM)){
return XTOK_CIM;
}
}
return 0;
}
static int procNameSpace(parseUnion * lvalp, ParserControl * parm)
{
static XmlElement elm[] = {
{"NAME"},
{NULL}
};
XmlAttr attr[1];
memset(attr, 0, sizeof(attr));
if (tagEquals(parm->xmb, "NAMESPACE")) {
if (attrsOk(parm->xmb, elm, attr, "NAMESPACE", ZTOK_NAMESPACE)) {
lvalp->xtokNameSpace.ns = attr[0].attr;
return XTOK_NAMESPACE;
}
}
return 0;
}
static int procExportMethodCall(parseUnion * lvalp, ParserControl * parm)
{
static XmlElement elm[] = {
{"NAME"},
{NULL}
};
XmlAttr attr[1];
memset(attr, 0, sizeof(attr));
if (tagEquals(parm->xmb, "EXPMETHODCALL")) {
if (attrsOk(parm->xmb, elm, attr, "EXPMETHODCALL", ZTOK_EXPMETHODCALL)) {
if (strcasecmp(attr[0].attr, "ExportIndication") == 0) {
return XTOK_EXPORTINDICATION;
}
}
}
return 0;
}
static int procInstance(parseUnion * lvalp, ParserControl * parm)
{
static XmlElement elm[] = {
{"CLASSNAME"},
{NULL}
};
XmlAttr attr[1];
memset(attr, 0, sizeof(attr));
if (tagEquals(parm->xmb, "INSTANCE")) {
if (attrsOk(parm->xmb, elm, attr, "INSTANCE", ZTOK_INSTANCE)) {
memset(&lvalp->xtokInstance, 0, sizeof(XtokInstance));
lvalp->xtokInstance.className = attr[0].attr;
return XTOK_INSTANCE;
}
}
return 0;
}
static int procExParamValue(parseUnion * lvalp, ParserControl * parm)
{
static XmlElement elm[] = {
{"NAME"},
{NULL}
};
XmlAttr attr[1];
memset(attr, 0, sizeof(attr));
if (tagEquals(parm->xmb, "EXPPARAMVALUE")) {
if (attrsOk(parm->xmb, elm, attr, "EXPPARAMVALUE", ZTOK_EXPPARAMVALUE)) {
if (strcasecmp(attr[0].attr, "NewIndication") == 0) {
return XTOK_EP_INSTANCE;
}
}
}
return 0;
}
static int procIMethodResp(parseUnion * lvalp, ParserControl * parm)
{
static XmlElement elm[] = {
{"NAME"},
{NULL}
};
XmlAttr attr[1];
memset(attr, 0, sizeof(attr));
if (tagEquals(parm->xmb, "IMETHODRESPONSE")) {
if (attrsOk(parm->xmb, elm, attr, "IMETHODRESPONSE", ZTOK_IMETHODRESP)) {
/*lvalp->xtokMessage.id = attr[0].attr;*/
parm->respHdr.id = attr[0].attr;
return XTOK_IMETHODRESP;
}
}
return 0;
}
static int procMessage(parseUnion * lvalp, ParserControl * parm)
{
static XmlElement elm[] = {
{"ID"},
{"PROTOCOLVERSION"},
{NULL}
};
XmlAttr attr[2];
memset(attr, 0, sizeof(attr));
if (tagEquals(parm->xmb, "MESSAGE")) {
if (attrsOk(parm->xmb, elm, attr, "MESSAGE", ZTOK_MESSAGE)) {
lvalp->xtokMessage.id = attr[0].attr;
parm->respHdr.id = attr[0].attr;
return XTOK_MESSAGE;
}
}
return 0;
}
static int procErrorResp(parseUnion * lvalp, ParserControl * parm)
{
static XmlElement elm[] = {
{"CODE"},
{"DESCRIPTION"},
{NULL}
};
XmlAttr attr[2];
memset(attr, 0, sizeof(attr));
if (tagEquals(parm->xmb, "ERROR")) {
if (attrsOk(parm->xmb, elm, attr, "ERROR", ZTOK_ERROR)) {
lvalp->xtokErrorResp.code = attr[0].attr;
lvalp->xtokErrorResp.description = attr[1].attr;
return XTOK_ERROR;
}
}
return 0;
}
static int procClass(parseUnion * lvalp, ParserControl * parm)
{
static XmlElement elm[] = {
{"NAME"},
{"SUPERCLASS"},
{NULL}
};
XmlAttr attr[2];
memset(attr, 0, sizeof(attr));
if (tagEquals(parm->xmb, "CLASS")) {
if (attrsOk(parm->xmb, elm, attr, "CLASS", ZTOK_CLASS)) {
memset(&lvalp->xtokClass, 0, sizeof(XtokClass));
lvalp->xtokClass.className = attr[0].attr;
lvalp->xtokClass.superClass = attr[1].attr;
return XTOK_CLASS;
}
}
return 0;
}
static int procRetValue(parseUnion * lvalp, ParserControl * parm)
{
if (tagEquals(parm->xmb, "RETURNVALUE")) {
static XmlElement elm[] = {
{"PARAMTYPE"},
{"EMBEDDEDOBJECT"},
{NULL}
};
XmlAttr attr[3];
int i;
memset(attr, 0, sizeof(attr));
if (attrsOk(parm->xmb, elm, attr, "RETURNVALUE", ZTOK_RETVALUE)) {
lvalp->xtokReturnValue.type = CMPI_null;
if (attr[0].attr) {
lvalp->xtokReturnValue.type = xmlToCmpiType(attr[0].attr);
}
return XTOK_RETVALUE;
}
}
return 0;
}
static int procKeyValue(parseUnion * lvalp, ParserControl * parm)
{
static XmlElement elm[] = {
{"VALUETYPE"},
{NULL}
};
XmlAttr attr[1] = {
{NULL}
};
char *val;
memset(attr, 0, sizeof(attr));
if (tagEquals(parm->xmb, "KEYVALUE")) {
if (attrsOk(parm->xmb, elm, attr, "KEYVALUE", ZTOK_KEYVALUE)) {
val = getContent(parm->xmb);
lvalp->xtokKeyValue.valueType = attr[0].attr;
lvalp->xtokKeyValue.value = val;
return XTOK_KEYVALUE;
}
}
return 0;
}
static int procParamRef(parseUnion * lvalp, ParserControl * parm)
{
static XmlElement elm[] =
{ {"NAME"},
{"REFERENCECLASS"},
{NULL}
};
XmlAttr attr[2];
memset(attr, 0, sizeof(attr));
if (tagEquals(parm->xmb, "PARAMETER.REFERENCE")) {
attr[1].attr = NULL;
if (attrsOk(parm->xmb, elm, attr, "PARAMETER.REFERENCE", ZTOK_PARAMREF)) {
memset(&lvalp->xtokParam, 0, sizeof(XtokParam));
lvalp->xtokParam.pType = ZTOK_PARAMREF;
lvalp->xtokParam.name = attr[0].attr;
lvalp->xtokParam.refClass = attr[1].attr;
lvalp->xtokParam.type = CMPI_ref;
return XTOK_PARAMREF;
}
}
return 0;
}
static int procQualifier(parseUnion * lvalp, ParserControl * parm)
{
static XmlElement elm[] = { {"NAME"},
{"TYPE"},
{"PROPAGATED"},
{"OVERRIDABLE"},
{"TOSUBCLASS"},
{"TOINSTANCE"},
{"TRANSLATABLE"},
{NULL}
};
XmlAttr attr[8];
int i, m;
memset(attr, 0, sizeof(attr));
if (tagEquals(parm->xmb, "QUALIFIER")) {
if (attrsOk(parm->xmb, elm, attr, "QUALIFIER", ZTOK_QUALIFIER)) {
memset(&lvalp->xtokQualifier, 0, sizeof(XtokQualifier));
lvalp->xtokQualifier.name = attr[0].attr;
lvalp->xtokQualifier.type = xmlToCmpiType(attr[1].attr);
if (attr[2].attr)
lvalp->xtokQualifier.propagated = !strcasecmp(attr[2].attr, "true");
if (attr[3].attr)
lvalp->xtokQualifier.overridable =
!strcasecmp(attr[3].attr, "true");
if (attr[4].attr)
lvalp->xtokQualifier.tosubclass = !strcasecmp(attr[4].attr, "true");
if (attr[5].attr)
lvalp->xtokQualifier.toinstance = !strcasecmp(attr[5].attr, "true");
if (attr[6].attr)
lvalp->xtokQualifier.translatable =
!strcasecmp(attr[6].attr, "true");
return XTOK_QUALIFIER;
}
}
return 0;
}
void ProtocolTreeNode::require(ProtocolTreeNode *node, const string& tag)
{
if (!tagEquals(node, tag))
throw WAException("failed require. node:" + node->toString() + "tag: " + tag, WAException::CORRUPT_STREAM_EX, 0);
}
