← Back to branch summary

~ubuntu-branches/ubuntu/utopic/sblim-sfcc/utopic-proposed

« back to all changes in this revision

Viewing changes to backend/cimxml/grammar.c

  • Committer: Bazaar Package Importer
  • Author(s): Thierry Carrez
  • Date: 2009-08-19 14:41:55 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20090819144155-jb46y5kmluacii70
Tags: 2.2.0-0ubuntu1
* New upstream version.
* debian/libcimcclient0.install: Ship missing libcmpisfcc library
* debian/control:
  - Switch to libcurl4-openssl-dev to match the rest of the SBLIM stack
  - Bump debhelper depend to >=5 to match debian/compat
  - Fix section names, add missing ${misc:Depends}
* debian/copyright: Add missing copyright notice
* debian/rules: Removed spurious DH_MAKESHLIBS argument

Show diffs side-by-side

added added

removed removed

Lines of Context:
backend/cimxml/grammar.c
 
1
/*
 
2
 * $id$
 
3
 *
 
4
 *  © Copyright IBM Corp. 2007
 
5
 *
 
6
 * THIS FILE IS PROVIDED UNDER THE TERMS OF THE ECLIPSE PUBLIC LICENSE
 
7
 * ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS FILE
 
8
 * CONSTITUTES RECIPIENTS ACCEPTANCE OF THE AGREEMENT.
 
9
 *
 
10
 * You can obtain a current copy of the Eclipse Public License from
 
11
 * http://www.opensource.org/licenses/eclipse-1.0.php
 
12
 *
 
13
 * Author:       Sven Schuetz <sven@de.ibm.com>
 
14
 *
 
15
 * Description:
 
16
 *
 
17
 * CIM XML parser for sfcc to be used in connection with lexer cimXmlParser.c
 
18
 *
 
19
*/
 
20
 
 
21
#include "grammar.h"
 
22
#include "cimXmlParser.h"
 
23
#include "sfcUtil/utilft.h"
 
24
#include "parserUtil.h"
 
25
 
 
26
 
 
27
static int ct = 0;
 
28
static int dontLex = 0;
 
29
 
 
30
 
 
31
static void parseError(char* tokExp, int tokFound, ParserControl *parm)
 
32
{
 
33
        printf("Parse error. Expected token(s) %s, found tag number %d (see cimXmlParser.h) and following xml: %.255s...\nAborting.\n", tokExp, tokFound, parm->xmb->cur+1);
 
34
        exit(0);
 
35
}
 
36
 
 
37
 
 
38
static int localLex(parseUnion *lvalp, ParserControl *parm)
 
39
{
 
40
    if(! dontLex) {
 
41
        ct = sfccLex(lvalp, parm);
 
42
    }
 
43
    else {
 
44
        dontLex = 0;
 
45
        return ct;
 
46
    }
 
47
    return ct;
 
48
}
 
49
 
 
50
 
 
51
void startParsing(ParserControl *parm)
 
52
{
 
53
    parseUnion stateUnion;
 
54
    start(parm, &stateUnion);
 
55
}
 
56
 
 
57
static void start(ParserControl *parm, parseUnion *stateUnion)
 
58
{
 
59
        parseUnion lvalp;
 
60
        ct = localLex(stateUnion, parm);
 
61
        if(ct == XTOK_XML) {
 
62
                ct = localLex(stateUnion, parm);
 
63
                if(ct == ZTOK_XML) {
 
64
                        cim(parm, stateUnion);
 
65
                }
 
66
                else {
 
67
                        parseError("ZTOK_XML", ct, parm);
 
68
                }
 
69
        }
 
70
        else {
 
71
                parseError("XTOK_XML", ct, parm);
 
72
        }
 
73
}
 
74
 
 
75
static void cim(ParserControl *parm, parseUnion *stateUnion)
 
76
{
 
77
        parseUnion lvalp;
 
78
        ct = localLex(stateUnion, parm);
 
79
        if(ct == XTOK_CIM) {
 
80
                message(parm, (parseUnion*)&stateUnion->xtokMessage);
 
81
                ct = localLex(stateUnion, parm);
 
82
                if(ct == ZTOK_CIM) {
 
83
                }
 
84
                else {
 
85
                        parseError("ZTOK_CIM", ct, parm);
 
86
                }
 
87
        }
 
88
        else {
 
89
                parseError("XTOK_CIM", ct, parm);
 
90
        }
 
91
}
 
92
 
 
93
static void message(ParserControl *parm, parseUnion *stateUnion)
 
94
{
 
95
        parseUnion lvalp;
 
96
        ct = localLex((parseUnion*)&stateUnion->xtokMessage, parm);
 
97
        if(ct == XTOK_MESSAGE) {
 
98
                messageContent(parm, stateUnion);
 
99
                ct = localLex((parseUnion*)&stateUnion->xtokMessage, parm);
 
100
                if(ct == ZTOK_MESSAGE) {
 
101
                }
 
102
                else {
 
103
                        parseError("ZTOK_MESSAGE", ct, parm);
 
104
                }
 
105
        }
 
106
        else {
 
107
                parseError("XTOK_MESSAGE", ct, parm);
 
108
        }
 
109
}
 
110
 
 
111
static void messageContent(ParserControl *parm, parseUnion *stateUnion)
 
112
{
 
113
        parseUnion lvalp;
 
114
        ct = localLex(stateUnion, parm);
 
115
        if(ct == XTOK_SIMPLERSP) {
 
116
                simpleRspContent(parm, (parseUnion*)&stateUnion->xtokSimpleRespContent);
 
117
                ct = localLex(stateUnion, parm);
 
118
                if(ct == ZTOK_SIMPLERSP) {
 
119
                }
 
120
                else {
 
121
                        parseError("ZTOK_SIMPLERSP", ct, parm);
 
122
                }
 
123
        }
 
124
        else if(ct == XTOK_SIMPLEEXPREQ) {
 
125
                exportIndication(parm, stateUnion);
 
126
                ct = localLex(stateUnion, parm);
 
127
                if(ct == ZTOK_SIMPLEEXPREQ) {
 
128
                }
 
129
                else {
 
130
                        parseError("ZTOK_SIMPLEEXPREQ", ct, parm);
 
131
                }
 
132
        }
 
133
        else {
 
134
                parseError("XTOK_SIMPLERSP", ct, parm);
 
135
        }
 
136
}
 
137
 
 
138
static void simpleRspContent(ParserControl *parm, parseUnion *stateUnion)
 
139
{
 
140
        parseUnion lvalp;
 
141
        ct = localLex((parseUnion*)&stateUnion->xtokSimpleRespContent, parm);
 
142
        if(ct == XTOK_METHODRESP) {
 
143
                methodRespContent(parm, (parseUnion*)&stateUnion->xtokSimpleRespContent.resp);
 
144
                setReturnArgs(parm, &stateUnion->xtokSimpleRespContent.resp.values);
 
145
                ct = localLex((parseUnion*)&stateUnion->xtokSimpleRespContent, parm);
 
146
                if(ct == ZTOK_METHODRESP) {
 
147
                }
 
148
                else {
 
149
                        parseError("ZTOK_METHODRESP", ct, parm);
 
150
                }
 
151
        }
 
152
        else if(ct == XTOK_IMETHODRESP) {
 
153
                iMethodRespContent(parm, stateUnion);
 
154
                ct = localLex((parseUnion*)&stateUnion->xtokSimpleRespContent, parm);
 
155
                if(ct == ZTOK_IMETHODRESP) {
 
156
                }
 
157
                else {
 
158
                        parseError("ZTOK_IMETHODRESP", ct, parm);
 
159
                }
 
160
        }
 
161
        else {
 
162
                parseError("XTOK_METHODRESP", ct, parm);
 
163
        }
 
164
}
 
165
 
 
166
static void exportIndication(ParserControl *parm, parseUnion *stateUnion)
 
167
{
 
168
        parseUnion lvalp;
 
169
        ct = localLex(stateUnion, parm);
 
170
        if(ct == XTOK_EXPORTINDICATION) {
 
171
                exParamValue(parm, stateUnion);
 
172
                ct = localLex(stateUnion, parm);
 
173
                if(ct == ZTOK_EXPMETHODCALL) {
 
174
                }
 
175
                else {
 
176
                        parseError("ZTOK_EXPMETHODCALL", ct, parm);
 
177
                }
 
178
        }
 
179
        else {
 
180
                parseError("XTOK_EXPORTINDICATION", ct, parm);
 
181
        }
 
182
}
 
183
 
 
184
static void exParamValue(ParserControl *parm, parseUnion *stateUnion)
 
185
{
 
186
        parseUnion lvalp;
 
187
        CMPIInstance *inst;
 
188
        ct = localLex(stateUnion, parm);
 
189
        if(ct == XTOK_EP_INSTANCE) {
 
190
                ct = localLex(&lvalp, parm);
 
191
                dontLex = 1;
 
192
                if(ct == XTOK_INSTANCE) {
 
193
                        dontLex = 1;
 
194
                        instance(parm, (parseUnion*)&lvalp.xtokInstance);
 
195
                        inst = native_new_CMPIInstance(NULL,NULL);
 
196
                        setInstNsAndCn(inst,parm->da_nameSpace,lvalp.xtokInstance.className);
 
197
                        setInstProperties(inst, &lvalp.xtokInstance.properties);
 
198
                        simpleArrayAdd(parm->respHdr.rvArray,(CMPIValue*)&inst,CMPI_instance);
 
199
                }
 
200
                ct = localLex(stateUnion, parm);
 
201
                if(ct == ZTOK_EXPPARAMVALUE) {
 
202
                }
 
203
                else {
 
204
                        parseError("ZTOK_EXPPARAMVALUE or XTOK_INSTANCE", ct, parm);
 
205
                }
 
206
        }
 
207
        else {
 
208
                parseError("XTOK_EP_INSTANCE", ct, parm);
 
209
        }
 
210
}
 
211
 
 
212
static void methodRespContent(ParserControl *parm, parseUnion *stateUnion)
 
213
{
 
214
        parseUnion lvalp;
 
215
        ct = localLex(&lvalp, parm);
 
216
        if(ct == XTOK_ERROR) {
 
217
                dontLex = 1;
 
218
                error(parm, (parseUnion*)&lvalp.xtokErrorResp);
 
219
        }
 
220
        else if(ct == XTOK_RETVALUE || ct == XTOK_PARAMVALUE) {
 
221
                dontLex = 1;
 
222
                if(ct == XTOK_RETVALUE) {
 
223
                        dontLex = 1;
 
224
                        returnValue(parm, (parseUnion*)&lvalp.xtokReturnValue);
 
225
                }
 
226
                ct = localLex(&lvalp, parm);
 
227
                dontLex = 1;
 
228
                if(ct == XTOK_PARAMVALUE) {
 
229
                        do {
 
230
                                dontLex = 1;
 
231
                                paramValue(parm, (parseUnion*)&lvalp.xtokParamValue);
 
232
                                addParamValue(parm, &stateUnion->xtokMethodRespContent.values, &lvalp.xtokParamValue);
 
233
                                ct = localLex(&lvalp, parm);
 
234
                        }
 
235
                        while(ct == XTOK_PARAMVALUE);
 
236
                        dontLex = 1;
 
237
                }
 
238
        }
 
239
        else if(ct == ZTOK_METHODRESP) {
 
240
                dontLex = 1;
 
241
        }
 
242
        else {
 
243
                parseError("XTOK_ERROR or XTOK_RETVALUE or XTOK_PARAMVALUE or ZTOK_METHODRESP", ct, parm);
 
244
        }
 
245
}
 
246
 
 
247
static void iMethodRespContent(ParserControl *parm, parseUnion *stateUnion)
 
248
{
 
249
        parseUnion lvalp;
 
250
        ct = localLex(&lvalp, parm);
 
251
        if(ct == XTOK_ERROR) {
 
252
                dontLex = 1;
 
253
                error(parm, (parseUnion*)&lvalp.xtokErrorResp);
 
254
        }
 
255
        else if(ct == XTOK_IRETVALUE) {
 
256
                dontLex = 1;
 
257
                iReturnValue(parm, stateUnion);
 
258
        }
 
259
        else {
 
260
                parseError("XTOK_ERROR or XTOK_IRETVALUE", ct, parm);
 
261
        }
 
262
}
 
263
 
 
264
static void error(ParserControl *parm, parseUnion *stateUnion)
 
265
{
 
266
        parseUnion lvalp;
 
267
        ct = localLex((parseUnion*)&stateUnion->xtokErrorResp, parm);
 
268
        if(ct == XTOK_ERROR) {
 
269
                setError(parm, &stateUnion->xtokErrorResp);
 
270
                ct = localLex((parseUnion*)&stateUnion->xtokErrorResp, parm);
 
271
                if(ct == ZTOK_ERROR) {
 
272
                }
 
273
                else {
 
274
                        parseError("ZTOK_ERROR", ct, parm);
 
275
                }
 
276
        }
 
277
        else {
 
278
                parseError("XTOK_ERROR", ct, parm);
 
279
        }
 
280
}
 
281
 
 
282
static void returnValue(ParserControl *parm, parseUnion *stateUnion)
 
283
{
 
284
        parseUnion lvalp;
 
285
        CMPIType  t;
 
286
        CMPIValue val;
 
287
        CMPIInstance *inst;
 
288
        ct = localLex((parseUnion*)&stateUnion->xtokReturnValue, parm);
 
289
        if(ct == XTOK_RETVALUE) {
 
290
                returnValueData(parm, (parseUnion*)&stateUnion->xtokReturnValue.data);
 
291
                if(stateUnion->xtokReturnValue.data.type == CMPI_ref) {
 
292
                        t = CMPI_ref;
 
293
                        val = str2CMPIValue(t, NULL, &stateUnion->xtokReturnValue.data.ref);
 
294
                }
 
295
                else if(stateUnion->xtokReturnValue.data.value.type == typeValue_Instance) {
 
296
                        t = CMPI_instance;
 
297
                        inst = native_new_CMPIInstance(NULL,NULL);
 
298
                        setInstNsAndCn(inst,parm->da_nameSpace,stateUnion->xtokReturnValue.data.value.data.inst->className);
 
299
                        setInstProperties(inst, &stateUnion->xtokReturnValue.data.value.data.inst->properties);
 
300
                        val.inst = inst;
 
301
                }
 
302
                else {
 
303
                        t = stateUnion->xtokReturnValue.type;
 
304
                        if (t == CMPI_null) {
 
305
                                t = guessType(stateUnion->xtokReturnValue.data.value.data.value);
 
306
                        }
 
307
                        val = str2CMPIValue(t, stateUnion->xtokReturnValue.data.value.data.value, NULL);
 
308
                }
 
309
                simpleArrayAdd(parm->respHdr.rvArray, (CMPIValue*)&val, t);
 
310
                ct = localLex((parseUnion*)&stateUnion->xtokReturnValue, parm);
 
311
                if(ct == ZTOK_RETVALUE) {
 
312
                }
 
313
                else {
 
314
                        parseError("ZTOK_RETVALUE", ct, parm);
 
315
                }
 
316
        }
 
317
        else {
 
318
                parseError("XTOK_RETVALUE", ct, parm);
 
319
        }
 
320
}
 
321
 
 
322
static void returnValueData(ParserControl *parm, parseUnion *stateUnion)
 
323
{
 
324
        parseUnion lvalp;
 
325
        ct = localLex((parseUnion*)&stateUnion->xtokReturnValueData, parm);
 
326
        if(ct == XTOK_VALUE) {
 
327
                dontLex = 1;
 
328
                value(parm, (parseUnion*)&stateUnion->xtokReturnValueData.value);
 
329
        }
 
330
        else if(ct == XTOK_VALUEREFERENCE) {
 
331
                dontLex = 1;
 
332
                valueReference(parm, (parseUnion*)&stateUnion->xtokReturnValueData.ref);
 
333
                stateUnion->xtokReturnValueData.type = CMPI_ref;
 
334
        }
 
335
        else {
 
336
                parseError("XTOK_VALUE or XTOK_VALUEREFERENCE", ct, parm);
 
337
        }
 
338
}
 
339
 
 
340
static void paramValue(ParserControl *parm, parseUnion *stateUnion)
 
341
{
 
342
        parseUnion lvalp;
 
343
        ct = localLex((parseUnion*)&stateUnion->xtokParamValue, parm);
 
344
        if(ct == XTOK_PARAMVALUE) {
 
345
                ct = localLex(&lvalp, parm);
 
346
                dontLex = 1;
 
347
                if(ct == XTOK_VALUE || ct == XTOK_VALUEREFERENCE || ct == XTOK_VALUEARRAY || ct == XTOK_VALUEREFARRAY) {
 
348
                        dontLex = 1;
 
349
                        paramValueData(parm, (parseUnion*)&lvalp.xtokParamValueData);
 
350
                        stateUnion->xtokParamValue.data = lvalp.xtokParamValueData;
 
351
                        if(lvalp.xtokParamValueData.type == CMPI_instance) {
 
352
                                stateUnion->xtokParamValue.type = CMPI_instance;
 
353
                        }
 
354
                        else {
 
355
                                stateUnion->xtokParamValue.type |= lvalp.xtokParamValueData.type;
 
356
                        }
 
357
                }
 
358
                ct = localLex((parseUnion*)&stateUnion->xtokParamValue, parm);
 
359
                if(ct == ZTOK_PARAMVALUE) {
 
360
                }
 
361
                else {
 
362
                        parseError("ZTOK_PARAMVALUE or XTOK_VALUE or XTOK_VALUEREFERENCE or XTOK_VALUEARRAY or XTOK_VALUEREFARRAY", ct, parm);
 
363
                }
 
364
        }
 
365
        else {
 
366
                parseError("XTOK_PARAMVALUE", ct, parm);
 
367
        }
 
368
}
 
369
 
 
370
static void paramValueData(ParserControl *parm, parseUnion *stateUnion)
 
371
{
 
372
        parseUnion lvalp;
 
373
        ct = localLex((parseUnion*)&stateUnion->xtokParamValueData, parm);
 
374
        if(ct == XTOK_VALUE) {
 
375
                dontLex = 1;
 
376
                value(parm, (parseUnion*)&stateUnion->xtokParamValueData.value);
 
377
                if(stateUnion->xtokParamValueData.value.type == typeValue_Instance) {
 
378
                        stateUnion->xtokParamValueData.type = CMPI_instance;
 
379
                }
 
380
        }
 
381
        else if(ct == XTOK_VALUEREFERENCE) {
 
382
                dontLex = 1;
 
383
                valueReference(parm, (parseUnion*)&stateUnion->xtokParamValueData.valueRef);
 
384
                stateUnion->xtokParamValueData.type = CMPI_ref;
 
385
        }
 
386
        else if(ct == XTOK_VALUEARRAY) {
 
387
                dontLex = 1;
 
388
                valueArray(parm, (parseUnion*)&stateUnion->xtokParamValueData.valueArray);
 
389
                stateUnion->xtokParamValueData.type |= CMPI_ARRAY;
 
390
        }
 
391
        else if(ct == XTOK_VALUEREFARRAY) {
 
392
                dontLex = 1;
 
393
                valueRefArray(parm, (parseUnion*)&stateUnion->xtokParamValueData.valueRefArray);
 
394
                stateUnion->xtokParamValueData.type = CMPI_refA;
 
395
        }
 
396
        else {
 
397
                parseError("XTOK_VALUE or XTOK_VALUEREFERENCE or XTOK_VALUEARRAY or XTOK_VALUEREFARRAY", ct, parm);
 
398
        }
 
399
}
 
400
 
 
401
static void iReturnValue(ParserControl *parm, parseUnion *stateUnion)
 
402
{
 
403
        parseUnion lvalp;
 
404
        ct = localLex(stateUnion, parm);
 
405
        if(ct == XTOK_IRETVALUE) {
 
406
                iReturnValueContent(parm, stateUnion);
 
407
                ct = localLex(stateUnion, parm);
 
408
                if(ct == ZTOK_IRETVALUE) {
 
409
                }
 
410
                else {
 
411
                        parseError("ZTOK_IRETVALUE", ct, parm);
 
412
                }
 
413
        }
 
414
        else {
 
415
                parseError("XTOK_IRETVALUE", ct, parm);
 
416
        }
 
417
}
 
418
 
 
419
static void iReturnValueContent(ParserControl *parm, parseUnion *stateUnion)
 
420
{
 
421
        parseUnion lvalp;
 
422
        CMPIObjectPath *op;
 
423
        CMPIInstance *inst;
 
424
        CMPIConstClass *cls;
 
425
        ct = localLex(&lvalp, parm);
 
426
        dontLex = 1;
 
427
        if(ct == XTOK_CLASS) {
 
428
                do {
 
429
                        dontLex = 1;
 
430
                        class(parm, (parseUnion*)&lvalp.xtokClass);
 
431
                        cls = native_new_CMPIConstClass(lvalp.xtokClass.className,NULL);
 
432
                        setClassProperties(cls, &lvalp.xtokClass.properties);
 
433
                        simpleArrayAdd(parm->respHdr.rvArray,(CMPIValue*)&cls,CMPI_class);
 
434
                        ct = localLex(&lvalp, parm);
 
435
                }
 
436
                while(ct == XTOK_CLASS);
 
437
                dontLex = 1;
 
438
        }
 
439
        else if(ct == XTOK_CLASSNAME) {
 
440
                do {
 
441
                        dontLex = 1;
 
442
                        className(parm, (parseUnion*)&lvalp.xtokClassName);
 
443
                        op = newCMPIObjectPath(NULL, lvalp.xtokClassName.value, NULL);
 
444
                        simpleArrayAdd(parm->respHdr.rvArray,(CMPIValue*)&op,CMPI_ref);
 
445
                        ct = localLex(&lvalp, parm);
 
446
                }
 
447
                while(ct == XTOK_CLASSNAME);
 
448
                dontLex = 1;
 
449
        }
 
450
        else if(ct == XTOK_INSTANCE) {
 
451
                do {
 
452
                        dontLex = 1;
 
453
                        instance(parm, (parseUnion*)&lvalp.xtokInstance);
 
454
                        inst = native_new_CMPIInstance(NULL,NULL);
 
455
                        setInstNsAndCn(inst,parm->da_nameSpace,lvalp.xtokInstance.className);
 
456
                        setInstProperties(inst, &lvalp.xtokInstance.properties);
 
457
                        simpleArrayAdd(parm->respHdr.rvArray,(CMPIValue*)&inst,CMPI_instance);
 
458
                        ct = localLex(&lvalp, parm);
 
459
                }
 
460
                while(ct == XTOK_INSTANCE);
 
461
                dontLex = 1;
 
462
        }
 
463
        else if(ct == XTOK_INSTANCENAME) {
 
464
                do {
 
465
                        dontLex = 1;
 
466
                        instanceName(parm, (parseUnion*)&lvalp.xtokInstanceName);
 
467
                        createPath(&op, &lvalp.xtokInstanceName);
 
468
                        simpleArrayAdd(parm->respHdr.rvArray,(CMPIValue*)&op,CMPI_ref);
 
469
                        ct = localLex(&lvalp, parm);
 
470
                }
 
471
                while(ct == XTOK_INSTANCENAME);
 
472
                dontLex = 1;
 
473
        }
 
474
        else if(ct == XTOK_VALUENAMEDINSTANCE) {
 
475
                do {
 
476
                        dontLex = 1;
 
477
                        valueNamedInstance(parm, (parseUnion*)&lvalp.xtokNamedInstance);
 
478
                        createPath(&op,&(lvalp.xtokNamedInstance.path));
 
479
                        inst = native_new_CMPIInstance(op,NULL);
 
480
                        //setInstQualifiers(inst, &lvalp.xtokNamedInstance.instance.qualifiers);
 
481
                        setInstProperties(inst, &lvalp.xtokNamedInstance.instance.properties);
 
482
                        simpleArrayAdd(parm->respHdr.rvArray,(CMPIValue*)&inst,CMPI_instance);
 
483
                        ct = localLex(&lvalp, parm);
 
484
                }
 
485
                while(ct == XTOK_VALUENAMEDINSTANCE);
 
486
                dontLex = 1;
 
487
        }
 
488
        else if(ct == XTOK_OBJECTPATH) {
 
489
                do {
 
490
                        dontLex = 1;
 
491
                        objectPath(parm, (parseUnion*)&lvalp.xtokObjectPath);
 
492
                        createPath(&op, &lvalp.xtokObjectPath.path.instanceName);
 
493
                        CMSetNameSpace(op, lvalp.xtokObjectPath.path.path.nameSpacePath.value);
 
494
                        CMSetHostname(op, lvalp.xtokObjectPath.path.path.host.host);
 
495
                        simpleArrayAdd(parm->respHdr.rvArray,(CMPIValue*)&op,CMPI_ref);
 
496
                        ct = localLex(&lvalp, parm);
 
497
                }
 
498
                while(ct == XTOK_OBJECTPATH);
 
499
                dontLex = 1;
 
500
        }
 
501
        else if(ct == XTOK_VALUEOBJECTWITHPATH) {
 
502
                do {
 
503
                        dontLex = 1;
 
504
                        valueObjectWithPath(parm, (parseUnion*)&lvalp.xtokObjectWithPath);
 
505
                        ct = localLex(&lvalp, parm);
 
506
                }
 
507
                while(ct == XTOK_VALUEOBJECTWITHPATH);
 
508
                dontLex = 1;
 
509
        }
 
510
        else if(ct == XTOK_VALUE || ct == XTOK_VALUEARRAY || ct == XTOK_VALUEREFERENCE) {
 
511
                dontLex = 1;
 
512
                if(ct == XTOK_VALUE || ct == XTOK_VALUEARRAY || ct == XTOK_VALUEREFERENCE) {
 
513
                        dontLex = 1;
 
514
                        getPropertyRetValue(parm, (parseUnion*)&lvalp.xtokGetPropRetContent);
 
515
                }
 
516
        }
 
517
        else if(ct == ZTOK_IRETVALUE) {
 
518
                dontLex = 1;
 
519
        }
 
520
        else {
 
521
                parseError("XTOK_CLASS or XTOK_CLASSNAME or XTOK_INSTANCE or XTOK_INSTANCENAME or XTOK_VALUENAMEDINSTANCE or XTOK_OBJECTPATH or XTOK_VALUEOBJECTWITHPATH or XTOK_VALUE or ZTOK_IRETVALUE", ct, parm);
 
522
        }
 
523
}
 
524
 
 
525
static void getPropertyRetValue(ParserControl *parm, parseUnion *stateUnion)
 
526
{
 
527
        parseUnion lvalp;
 
528
        CMPIType  t;
 
529
        CMPIValue val;
 
530
        ct = localLex((parseUnion*)&stateUnion->xtokGetPropRetContent, parm);
 
531
        if(ct == XTOK_VALUE) {
 
532
                dontLex = 1;
 
533
                value(parm, (parseUnion*)&stateUnion->xtokGetPropRetContent.value);
 
534
                t   = guessType(stateUnion->xtokGetPropRetContent.value.data.value);
 
535
                val = str2CMPIValue(t, stateUnion->xtokGetPropRetContent.value.data.value, NULL);
 
536
                simpleArrayAdd(parm->respHdr.rvArray, (CMPIValue*)&val, t);
 
537
        }
 
538
        else if(ct == XTOK_VALUEARRAY) {
 
539
                dontLex = 1;
 
540
                valueArray(parm, (parseUnion*)&stateUnion->xtokGetPropRetContent.arr);
 
541
        }
 
542
        else if(ct == XTOK_VALUEREFERENCE) {
 
543
                dontLex = 1;
 
544
                valueReference(parm, (parseUnion*)&stateUnion->xtokGetPropRetContent.ref);
 
545
        }
 
546
        else {
 
547
                parseError("XTOK_VALUE or XTOK_VALUEARRAY or XTOK_VALUEREFERENCE", ct, parm);
 
548
        }
 
549
}
 
550
 
 
551
static void valueObjectWithPath(ParserControl *parm, parseUnion *stateUnion)
 
552
{
 
553
        parseUnion lvalp;
 
554
        ct = localLex((parseUnion*)&stateUnion->xtokObjectWithPath, parm);
 
555
        if(ct == XTOK_VALUEOBJECTWITHPATH) {
 
556
                valueObjectWithPathData(parm, (parseUnion*)&stateUnion->xtokObjectWithPath.object);
 
557
                stateUnion->xtokObjectWithPath.type = stateUnion->xtokObjectWithPath.object.type;
 
558
                ct = localLex((parseUnion*)&stateUnion->xtokObjectWithPath, parm);
 
559
                if(ct == ZTOK_VALUEOBJECTWITHPATH) {
 
560
                }
 
561
                else {
 
562
                        parseError("ZTOK_VALUEOBJECTWITHPATH", ct, parm);
 
563
                }
 
564
        }
 
565
        else {
 
566
                parseError("XTOK_VALUEOBJECTWITHPATH", ct, parm);
 
567
        }
 
568
}
 
569
 
 
570
static void valueObjectWithPathData(ParserControl *parm, parseUnion *stateUnion)
 
571
{
 
572
        parseUnion lvalp;
 
573
        CMPIObjectPath *op;
 
574
        CMPIInstance *inst;
 
575
        ct = localLex((parseUnion*)&stateUnion->xtokObjectWithPathData, parm);
 
576
        if(ct == XTOK_CLASSPATH) {
 
577
                dontLex = 1;
 
578
                classWithPath(parm, (parseUnion*)&stateUnion->xtokObjectWithPathData.cls);
 
579
                stateUnion->xtokObjectWithPathData.type = 1;
 
580
        }
 
581
        else if(ct == XTOK_INSTANCEPATH) {
 
582
                dontLex = 1;
 
583
                instanceWithPath(parm, (parseUnion*)&stateUnion->xtokObjectWithPathData.inst);
 
584
                stateUnion->xtokObjectWithPathData.type = 0;
 
585
                createPath(&op, &stateUnion->xtokObjectWithPathData.inst.path.instanceName);
 
586
                CMSetNameSpace(op, stateUnion->xtokObjectWithPathData.inst.path.path.nameSpacePath.value);
 
587
                CMSetHostname(op, stateUnion->xtokObjectWithPathData.inst.path.path.host.host);
 
588
                inst = native_new_CMPIInstance(op,NULL);
 
589
                setInstQualifiers(inst, &stateUnion->xtokObjectWithPathData.inst.inst.qualifiers);
 
590
                setInstProperties(inst, &stateUnion->xtokObjectWithPathData.inst.inst.properties);
 
591
                simpleArrayAdd(parm->respHdr.rvArray,(CMPIValue*)&inst,CMPI_instance);
 
592
        }
 
593
        else {
 
594
                parseError("XTOK_CLASSPATH or XTOK_INSTANCEPATH", ct, parm);
 
595
        }
 
596
}
 
597
 
 
598
static void classWithPath(ParserControl *parm, parseUnion *stateUnion)
 
599
{
 
600
        parseUnion lvalp;
 
601
        ct = localLex((parseUnion*)&stateUnion->xtokClassWithPath, parm);
 
602
        if(ct == XTOK_CLASSPATH) {
 
603
                dontLex = 1;
 
604
                classPath(parm, (parseUnion*)&stateUnion->xtokClassWithPath.path);
 
605
                class(parm, (parseUnion*)&stateUnion->xtokClassWithPath.cls);
 
606
        }
 
607
        else {
 
608
                parseError("XTOK_CLASSPATH or XTOK_CLASS", ct, parm);
 
609
        }
 
610
}
 
611
 
 
612
static void instanceWithPath(ParserControl *parm, parseUnion *stateUnion)
 
613
{
 
614
        parseUnion lvalp;
 
615
        ct = localLex((parseUnion*)&stateUnion->xtokInstanceWithPath, parm);
 
616
        if(ct == XTOK_INSTANCEPATH) {
 
617
                dontLex = 1;
 
618
                instancePath(parm, (parseUnion*)&stateUnion->xtokInstanceWithPath.path);
 
619
                instance(parm, (parseUnion*)&stateUnion->xtokInstanceWithPath.inst);
 
620
        }
 
621
        else {
 
622
                parseError("XTOK_INSTANCEPATH or XTOK_INSTANCE", ct, parm);
 
623
        }
 
624
}
 
625
 
 
626
static void class(ParserControl *parm, parseUnion *stateUnion)
 
627
{
 
628
        parseUnion lvalp;
 
629
        ct = localLex((parseUnion*)&stateUnion->xtokClass, parm);
 
630
        if(ct == XTOK_CLASS) {
 
631
                ct = localLex(&lvalp, parm);
 
632
                dontLex = 1;
 
633
                if(ct == XTOK_QUALIFIER) {
 
634
                        do {
 
635
                                dontLex = 1;
 
636
                                qualifier(parm, (parseUnion*)&lvalp.xtokQualifier);
 
637
                                addQualifier(parm,&stateUnion->xtokClass.qualifiers,&lvalp.xtokQualifier);
 
638
                                ct = localLex(&lvalp, parm);
 
639
                        }
 
640
                        while(ct == XTOK_QUALIFIER);
 
641
                        dontLex = 1;
 
642
                }
 
643
                ct = localLex(&lvalp, parm);
 
644
                dontLex = 1;
 
645
                if(ct == XTOK_PROPERTY || ct == XTOK_PROPERTYARRAY || ct == XTOK_PROPERTYREFERENCE) {
 
646
                        do {
 
647
                                dontLex = 1;
 
648
                                genProperty(parm, (parseUnion*)&lvalp.xtokProperty);
 
649
                                addProperty(parm,&stateUnion->xtokClass.properties,&lvalp.xtokProperty);
 
650
                                ct = localLex(&lvalp, parm);
 
651
                        }
 
652
                        while(ct == XTOK_PROPERTY || ct == XTOK_PROPERTYARRAY || ct == XTOK_PROPERTYREFERENCE);
 
653
                        dontLex = 1;
 
654
                }
 
655
                ct = localLex(&lvalp, parm);
 
656
                dontLex = 1;
 
657
                if(ct == XTOK_METHOD) {
 
658
                        do {
 
659
                                dontLex = 1;
 
660
                                method(parm, (parseUnion*)&lvalp.xtokMethod);
 
661
                                addMethod(parm,&stateUnion->xtokClass.methods,&lvalp.xtokMethod);
 
662
                                ct = localLex(&lvalp, parm);
 
663
                        }
 
664
                        while(ct == XTOK_METHOD);
 
665
                        dontLex = 1;
 
666
                }
 
667
                ct = localLex((parseUnion*)&stateUnion->xtokClass, parm);
 
668
                if(ct == ZTOK_CLASS) {
 
669
                }
 
670
                else {
 
671
                        parseError("ZTOK_CLASS or XTOK_METHOD or XTOK_PROPERTY or XTOK_PROPERTYARRAY or XTOK_PROPERTYREFERENCE or XTOK_QUALIFIER", ct, parm);
 
672
                }
 
673
        }
 
674
        else {
 
675
                parseError("XTOK_CLASS", ct, parm);
 
676
        }
 
677
}
 
678
 
 
679
static void method(ParserControl *parm, parseUnion *stateUnion)
 
680
{
 
681
        parseUnion lvalp;
 
682
        ct = localLex((parseUnion*)&stateUnion->xtokMethod, parm);
 
683
        if(ct == XTOK_METHOD) {
 
684
                ct = localLex(&lvalp, parm);
 
685
                dontLex = 1;
 
686
                if(ct == XTOK_QUALIFIER) {
 
687
                        do {
 
688
                                dontLex = 1;
 
689
                                qualifier(parm, (parseUnion*)&lvalp.xtokQualifier);
 
690
                                addQualifier(parm,&stateUnion->xtokMethod.qualifiers,&lvalp.xtokQualifier);
 
691
                                ct = localLex(&lvalp, parm);
 
692
                        }
 
693
                        while(ct == XTOK_QUALIFIER);
 
694
                        dontLex = 1;
 
695
                }
 
696
                ct = localLex(&lvalp, parm);
 
697
                dontLex = 1;
 
698
                if(ct == XTOK_PARAM || ct == XTOK_PARAMREF || ct == XTOK_PARAMARRAY || ct == XTOK_PARAMREFARRAY) {
 
699
                        do {
 
700
                                dontLex = 1;
 
701
                                methodData(parm, (parseUnion*)&lvalp.xtokMethodData);
 
702
                                ct = localLex(&lvalp, parm);
 
703
                        }
 
704
                        while(ct == XTOK_PARAM || ct == XTOK_PARAMREF || ct == XTOK_PARAMARRAY || ct == XTOK_PARAMREFARRAY);
 
705
                        dontLex = 1;
 
706
                }
 
707
                ct = localLex((parseUnion*)&stateUnion->xtokMethod, parm);
 
708
                if(ct == ZTOK_METHOD) {
 
709
                }
 
710
                else {
 
711
                        parseError("ZTOK_METHOD or XTOK_PARAM or XTOK_PARAMREF or XTOK_PARAMARRAY or XTOK_PARAMREFARRAY or XTOK_QUALIFIER", ct, parm);
 
712
                }
 
713
        }
 
714
        else {
 
715
                parseError("XTOK_METHOD", ct, parm);
 
716
        }
 
717
}
 
718
 
 
719
static void methodData(ParserControl *parm, parseUnion *stateUnion)
 
720
{
 
721
        parseUnion lvalp;
 
722
        if(ct == XTOK_PARAM) {
 
723
                dontLex = 1;
 
724
                if(ct == XTOK_PARAM) {
 
725
                        dontLex = 1;
 
726
                        parameter(parm, (parseUnion*)&lvalp.xtokParam);
 
727
                }
 
728
        }
 
729
        else if(ct == XTOK_PARAMREF) {
 
730
                dontLex = 1;
 
731
                if(ct == XTOK_PARAMREF) {
 
732
                        dontLex = 1;
 
733
                        parameterReference(parm, (parseUnion*)&lvalp.xtokParam);
 
734
                }
 
735
        }
 
736
        else if(ct == XTOK_PARAMARRAY) {
 
737
                dontLex = 1;
 
738
                if(ct == XTOK_PARAMARRAY) {
 
739
                        dontLex = 1;
 
740
                        parameterArray(parm, (parseUnion*)&lvalp.xtokParam);
 
741
                }
 
742
        }
 
743
        else if(ct == XTOK_PARAMREFARRAY) {
 
744
                dontLex = 1;
 
745
                if(ct == XTOK_PARAMREFARRAY) {
 
746
                        dontLex = 1;
 
747
                        parameterRefArray(parm, (parseUnion*)&lvalp.xtokParam);
 
748
                }
 
749
        }
 
750
        else {
 
751
                parseError("XTOK_PARAM or XTOK_PARAMREF or XTOK_PARAMARRAY or XTOK_PARAMREFARRAY", ct, parm);
 
752
        }
 
753
}
 
754
 
 
755
static void parameter(ParserControl *parm, parseUnion *stateUnion)
 
756
{
 
757
        parseUnion lvalp;
 
758
        ct = localLex((parseUnion*)&stateUnion->xtokParam, parm);
 
759
        if(ct == XTOK_PARAM) {
 
760
                ct = localLex(&lvalp, parm);
 
761
                dontLex = 1;
 
762
                if(ct == XTOK_QUALIFIER) {
 
763
                        do {
 
764
                                dontLex = 1;
 
765
                                qualifier(parm, (parseUnion*)&lvalp.xtokQualifier);
 
766
                                ct = localLex(&lvalp, parm);
 
767
                        }
 
768
                        while(ct == XTOK_QUALIFIER);
 
769
                        dontLex = 1;
 
770
                }
 
771
                ct = localLex((parseUnion*)&stateUnion->xtokParam, parm);
 
772
                if(ct == ZTOK_PARAM) {
 
773
                }
 
774
                else {
 
775
                        parseError("ZTOK_PARAM or XTOK_QUALIFIER", ct, parm);
 
776
                }
 
777
        }
 
778
        else {
 
779
                parseError("XTOK_PARAM", ct, parm);
 
780
        }
 
781
}
 
782
 
 
783
static void parameterReference(ParserControl *parm, parseUnion *stateUnion)
 
784
{
 
785
        parseUnion lvalp;
 
786
        ct = localLex((parseUnion*)&stateUnion->xtokParam, parm);
 
787
        if(ct == XTOK_PARAMREF) {
 
788
                ct = localLex(&lvalp, parm);
 
789
                dontLex = 1;
 
790
                if(ct == XTOK_QUALIFIER) {
 
791
                        do {
 
792
                                dontLex = 1;
 
793
                                qualifier(parm, (parseUnion*)&lvalp.xtokQualifier);
 
794
                                ct = localLex(&lvalp, parm);
 
795
                        }
 
796
                        while(ct == XTOK_QUALIFIER);
 
797
                        dontLex = 1;
 
798
                }
 
799
                ct = localLex((parseUnion*)&stateUnion->xtokParam, parm);
 
800
                if(ct == ZTOK_PARAMREF) {
 
801
                }
 
802
                else {
 
803
                        parseError("ZTOK_PARAMREF or XTOK_QUALIFIER", ct, parm);
 
804
                }
 
805
        }
 
806
        else {
 
807
                parseError("XTOK_PARAMREF", ct, parm);
 
808
        }
 
809
}
 
810
 
 
811
static void parameterRefArray(ParserControl *parm, parseUnion *stateUnion)
 
812
{
 
813
        parseUnion lvalp;
 
814
        ct = localLex((parseUnion*)&stateUnion->xtokParam, parm);
 
815
        if(ct == XTOK_PARAMREFARRAY) {
 
816
                ct = localLex(&lvalp, parm);
 
817
                dontLex = 1;
 
818
                if(ct == XTOK_QUALIFIER) {
 
819
                        do {
 
820
                                dontLex = 1;
 
821
                                qualifier(parm, (parseUnion*)&lvalp.xtokQualifier);
 
822
                                ct = localLex(&lvalp, parm);
 
823
                        }
 
824
                        while(ct == XTOK_QUALIFIER);
 
825
                        dontLex = 1;
 
826
                }
 
827
                ct = localLex((parseUnion*)&stateUnion->xtokParam, parm);
 
828
                if(ct == ZTOK_PARAMREFARRAY) {
 
829
                }
 
830
                else {
 
831
                        parseError("ZTOK_PARAMREFARRAY or XTOK_QUALIFIER", ct, parm);
 
832
                }
 
833
        }
 
834
        else {
 
835
                parseError("XTOK_PARAMREFARRAY", ct, parm);
 
836
        }
 
837
}
 
838
 
 
839
static void parameterArray(ParserControl *parm, parseUnion *stateUnion)
 
840
{
 
841
        parseUnion lvalp;
 
842
        ct = localLex((parseUnion*)&stateUnion->xtokParam, parm);
 
843
        if(ct == XTOK_PARAMARRAY) {
 
844
                ct = localLex(&lvalp, parm);
 
845
                dontLex = 1;
 
846
                if(ct == XTOK_QUALIFIER) {
 
847
                        do {
 
848
                                dontLex = 1;
 
849
                                qualifier(parm, (parseUnion*)&lvalp.xtokQualifier);
 
850
                                ct = localLex(&lvalp, parm);
 
851
                        }
 
852
                        while(ct == XTOK_QUALIFIER);
 
853
                        dontLex = 1;
 
854
                }
 
855
                ct = localLex((parseUnion*)&stateUnion->xtokParam, parm);
 
856
                if(ct == ZTOK_PARAMARRAY) {
 
857
                }
 
858
                else {
 
859
                        parseError("ZTOK_PARAMARRAY or XTOK_QUALIFIER", ct, parm);
 
860
                }
 
861
        }
 
862
        else {
 
863
                parseError("XTOK_PARAMARRAY", ct, parm);
 
864
        }
 
865
}
 
866
 
 
867
static void objectPath(ParserControl *parm, parseUnion *stateUnion)
 
868
{
 
869
        parseUnion lvalp;
 
870
        ct = localLex((parseUnion*)&stateUnion->xtokObjectPath, parm);
 
871
        if(ct == XTOK_OBJECTPATH) {
 
872
                instancePath(parm, (parseUnion*)&stateUnion->xtokObjectPath.path);
 
873
                ct = localLex((parseUnion*)&stateUnion->xtokObjectPath, parm);
 
874
                if(ct == ZTOK_OBJECTPATH) {
 
875
                }
 
876
                else {
 
877
                        parseError("ZTOK_OBJECTPATH", ct, parm);
 
878
                }
 
879
        }
 
880
        else {
 
881
                parseError("XTOK_OBJECTPATH", ct, parm);
 
882
        }
 
883
}
 
884
 
 
885
static void classPath(ParserControl *parm, parseUnion *stateUnion)
 
886
{
 
887
        parseUnion lvalp;
 
888
        ct = localLex((parseUnion*)&stateUnion->xtokClassPath, parm);
 
889
        if(ct == XTOK_CLASSPATH) {
 
890
                nameSpacePath(parm, (parseUnion*)&stateUnion->xtokClassPath.name);
 
891
                className(parm, (parseUnion*)&stateUnion->xtokClassPath.className);
 
892
                ct = localLex((parseUnion*)&stateUnion->xtokClassPath, parm);
 
893
                if(ct == ZTOK_CLASSPATH) {
 
894
                }
 
895
                else {
 
896
                        parseError("ZTOK_CLASSPATH", ct, parm);
 
897
                }
 
898
        }
 
899
        else {
 
900
                parseError("XTOK_CLASSPATH", ct, parm);
 
901
        }
 
902
}
 
903
 
 
904
static void className(ParserControl *parm, parseUnion *stateUnion)
 
905
{
 
906
        parseUnion lvalp;
 
907
        ct = localLex((parseUnion*)&stateUnion->xtokClassName, parm);
 
908
        if(ct == XTOK_CLASSNAME) {
 
909
                ct = localLex((parseUnion*)&stateUnion->xtokClassName, parm);
 
910
                if(ct == ZTOK_CLASSNAME) {
 
911
                }
 
912
                else {
 
913
                        parseError("ZTOK_CLASSNAME", ct, parm);
 
914
                }
 
915
        }
 
916
        else {
 
917
                parseError("XTOK_CLASSNAME", ct, parm);
 
918
        }
 
919
}
 
920
 
 
921
static void instancePath(ParserControl *parm, parseUnion *stateUnion)
 
922
{
 
923
        parseUnion lvalp;
 
924
        ct = localLex((parseUnion*)&stateUnion->xtokInstancePath, parm);
 
925
        if(ct == XTOK_INSTANCEPATH) {
 
926
                nameSpacePath(parm, (parseUnion*)&stateUnion->xtokInstancePath.path);
 
927
                instanceName(parm, (parseUnion*)&stateUnion->xtokInstancePath.instanceName);
 
928
                ct = localLex((parseUnion*)&stateUnion->xtokInstancePath, parm);
 
929
                if(ct == ZTOK_INSTANCEPATH) {
 
930
                }
 
931
                else {
 
932
                        parseError("ZTOK_INSTANCEPATH", ct, parm);
 
933
                }
 
934
        }
 
935
        else {
 
936
                parseError("XTOK_INSTANCEPATH", ct, parm);
 
937
        }
 
938
}
 
939
 
 
940
static void localInstancePath(ParserControl *parm, parseUnion *stateUnion)
 
941
{
 
942
        parseUnion lvalp;
 
943
        ct = localLex((parseUnion*)&stateUnion->xtokLocalInstancePath, parm);
 
944
        if(ct == XTOK_LOCALINSTANCEPATH) {
 
945
                localNameSpacePath(parm, (parseUnion*)&stateUnion->xtokLocalInstancePath.path);
 
946
                instanceName(parm, (parseUnion*)&stateUnion->xtokLocalInstancePath.instanceName);
 
947
                ct = localLex((parseUnion*)&stateUnion->xtokLocalInstancePath, parm);
 
948
                if(ct == ZTOK_LOCALINSTANCEPATH) {
 
949
                }
 
950
                else {
 
951
                        parseError("ZTOK_LOCALINSTANCEPATH", ct, parm);
 
952
                }
 
953
        }
 
954
        else {
 
955
                parseError("XTOK_LOCALINSTANCEPATH", ct, parm);
 
956
        }
 
957
}
 
958
 
 
959
static void nameSpacePath(ParserControl *parm, parseUnion *stateUnion)
 
960
{
 
961
        parseUnion lvalp;
 
962
        ct = localLex((parseUnion*)&stateUnion->xtokNameSpacePath, parm);
 
963
        if(ct == XTOK_NAMESPACEPATH) {
 
964
                host(parm, (parseUnion*)&stateUnion->xtokNameSpacePath.host);
 
965
                localNameSpacePath(parm, (parseUnion*)&stateUnion->xtokNameSpacePath.nameSpacePath);
 
966
                ct = localLex((parseUnion*)&stateUnion->xtokNameSpacePath, parm);
 
967
                if(ct == ZTOK_NAMESPACEPATH) {
 
968
                }
 
969
                else {
 
970
                        parseError("ZTOK_NAMESPACEPATH", ct, parm);
 
971
                }
 
972
        }
 
973
        else {
 
974
                parseError("XTOK_NAMESPACEPATH", ct, parm);
 
975
        }
 
976
}
 
977
 
 
978
static void host(ParserControl *parm, parseUnion *stateUnion)
 
979
{
 
980
        parseUnion lvalp;
 
981
        ct = localLex((parseUnion*)&stateUnion->xtokHost, parm);
 
982
        if(ct == XTOK_HOST) {
 
983
                ct = localLex((parseUnion*)&stateUnion->xtokHost, parm);
 
984
                if(ct == ZTOK_HOST) {
 
985
                }
 
986
                else {
 
987
                        parseError("ZTOK_HOST", ct, parm);
 
988
                }
 
989
        }
 
990
        else {
 
991
                parseError("XTOK_HOST", ct, parm);
 
992
        }
 
993
}
 
994
 
 
995
static void localNameSpacePath(ParserControl *parm, parseUnion *stateUnion)
 
996
{
 
997
        parseUnion lvalp;
 
998
        ct = localLex((parseUnion*)&stateUnion->xtokLocalNameSpacePath, parm);
 
999
        if(ct == XTOK_LOCALNAMESPACEPATH) {
 
1000
                ct = localLex(&lvalp, parm);
 
1001
                dontLex = 1;
 
1002
                if(ct == XTOK_NAMESPACE) {
 
1003
                        do {
 
1004
                                dontLex = 1;
 
1005
                                nameSpace(parm, (parseUnion*)&lvalp.xtokNameSpace);
 
1006
                                if(stateUnion->xtokLocalNameSpacePath.value) {
 
1007
                                        stateUnion->xtokLocalNameSpacePath.value = parser_realloc(parm->heap, stateUnion->xtokLocalNameSpacePath.value, strlen(stateUnion->xtokLocalNameSpacePath.value) + strlen(lvalp.xtokNameSpace.ns) + 2);
 
1008
                                        strcat(stateUnion->xtokLocalNameSpacePath.value, "/");
 
1009
                                        strcat(stateUnion->xtokLocalNameSpacePath.value, lvalp.xtokNameSpace.ns);
 
1010
                                }
 
1011
                                else {
 
1012
                                        stateUnion->xtokLocalNameSpacePath.value = parser_malloc(parm->heap, strlen(lvalp.xtokNameSpace.ns) + 1);
 
1013
                                        strcpy(stateUnion->xtokLocalNameSpacePath.value, lvalp.xtokNameSpace.ns);
 
1014
                                }
 
1015
                                ct = localLex(&lvalp, parm);
 
1016
                        }
 
1017
                        while(ct == XTOK_NAMESPACE);
 
1018
                        dontLex = 1;
 
1019
                }
 
1020
                ct = localLex((parseUnion*)&stateUnion->xtokLocalNameSpacePath, parm);
 
1021
                if(ct == ZTOK_LOCALNAMESPACEPATH) {
 
1022
                }
 
1023
                else {
 
1024
                        parseError("ZTOK_LOCALNAMESPACEPATH or XTOK_NAMESPACE", ct, parm);
 
1025
                }
 
1026
        }
 
1027
        else {
 
1028
                parseError("XTOK_LOCALNAMESPACEPATH", ct, parm);
 
1029
        }
 
1030
}
 
1031
 
 
1032
static void nameSpace(ParserControl *parm, parseUnion *stateUnion)
 
1033
{
 
1034
        parseUnion lvalp;
 
1035
        ct = localLex((parseUnion*)&stateUnion->xtokNameSpace, parm);
 
1036
        if(ct == XTOK_NAMESPACE) {
 
1037
                ct = localLex((parseUnion*)&stateUnion->xtokNameSpace, parm);
 
1038
                if(ct == ZTOK_NAMESPACE) {
 
1039
                }
 
1040
                else {
 
1041
                        parseError("ZTOK_NAMESPACE", ct, parm);
 
1042
                }
 
1043
        }
 
1044
        else {
 
1045
                parseError("XTOK_NAMESPACE", ct, parm);
 
1046
        }
 
1047
}
 
1048
 
 
1049
static void valueNamedInstance(ParserControl *parm, parseUnion *stateUnion)
 
1050
{
 
1051
        parseUnion lvalp;
 
1052
        ct = localLex((parseUnion*)&stateUnion->xtokNamedInstance, parm);
 
1053
        if(ct == XTOK_VALUENAMEDINSTANCE) {
 
1054
                instanceName(parm, (parseUnion*)&stateUnion->xtokNamedInstance.path);
 
1055
                instance(parm, (parseUnion*)&stateUnion->xtokNamedInstance.instance);
 
1056
                ct = localLex((parseUnion*)&stateUnion->xtokNamedInstance, parm);
 
1057
                if(ct == ZTOK_VALUENAMEDINSTANCE) {
 
1058
                }
 
1059
                else {
 
1060
                        parseError("ZTOK_VALUENAMEDINSTANCE", ct, parm);
 
1061
                }
 
1062
        }
 
1063
        else {
 
1064
                parseError("XTOK_VALUENAMEDINSTANCE", ct, parm);
 
1065
        }
 
1066
}
 
1067
 
 
1068
static void instance(ParserControl *parm, parseUnion *stateUnion)
 
1069
{
 
1070
        parseUnion lvalp;
 
1071
        ct = localLex((parseUnion*)&stateUnion->xtokInstance, parm);
 
1072
        if(ct == XTOK_INSTANCE) {
 
1073
                ct = localLex(&lvalp, parm);
 
1074
                dontLex = 1;
 
1075
                if(ct == XTOK_QUALIFIER) {
 
1076
                        do {
 
1077
                                dontLex = 1;
 
1078
                                qualifier(parm, (parseUnion*)&lvalp.xtokQualifier);
 
1079
                                addQualifier(parm,&stateUnion->xtokInstance.qualifiers,&lvalp.xtokQualifier);
 
1080
                                ct = localLex(&lvalp, parm);
 
1081
                        }
 
1082
                        while(ct == XTOK_QUALIFIER);
 
1083
                        dontLex = 1;
 
1084
                }
 
1085
                ct = localLex(&lvalp, parm);
 
1086
                dontLex = 1;
 
1087
                if(ct == XTOK_PROPERTY || ct == XTOK_PROPERTYARRAY || ct == XTOK_PROPERTYREFERENCE) {
 
1088
                        do {
 
1089
                                dontLex = 1;
 
1090
                                genProperty(parm, (parseUnion*)&lvalp.xtokProperty);
 
1091
                                addProperty(parm,&stateUnion->xtokInstance.properties,&lvalp.xtokProperty);
 
1092
                                ct = localLex(&lvalp, parm);
 
1093
                        }
 
1094
                        while(ct == XTOK_PROPERTY || ct == XTOK_PROPERTYARRAY || ct == XTOK_PROPERTYREFERENCE);
 
1095
                        dontLex = 1;
 
1096
                }
 
1097
                ct = localLex((parseUnion*)&stateUnion->xtokInstance, parm);
 
1098
                if(ct == ZTOK_INSTANCE) {
 
1099
                }
 
1100
                else {
 
1101
                        parseError("ZTOK_INSTANCE or XTOK_PROPERTY or XTOK_PROPERTYARRAY or XTOK_PROPERTYREFERENCE or XTOK_QUALIFIER", ct, parm);
 
1102
                }
 
1103
        }
 
1104
        else {
 
1105
                parseError("XTOK_INSTANCE", ct, parm);
 
1106
        }
 
1107
}
 
1108
 
 
1109
static void genProperty(ParserControl *parm, parseUnion *stateUnion)
 
1110
{
 
1111
        parseUnion lvalp;
 
1112
        ct = localLex((parseUnion*)&stateUnion->xtokProperty, parm);
 
1113
        if(ct == XTOK_PROPERTY) {
 
1114
                dontLex = 1;
 
1115
                property(parm, (parseUnion*)&stateUnion->xtokProperty.val);
 
1116
                if(stateUnion->xtokProperty.val.value.type == typeValue_Instance) {
 
1117
                        stateUnion->xtokProperty.valueType = CMPI_instance;
 
1118
                }
 
1119
        }
 
1120
        else if(ct == XTOK_PROPERTYARRAY) {
 
1121
                dontLex = 1;
 
1122
                propertyArray(parm, (parseUnion*)&stateUnion->xtokProperty.val);
 
1123
        }
 
1124
        else if(ct == XTOK_PROPERTYREFERENCE) {
 
1125
                dontLex = 1;
 
1126
                propertyReference(parm, (parseUnion*)&stateUnion->xtokProperty.val);
 
1127
        }
 
1128
        else {
 
1129
                parseError("XTOK_PROPERTY or XTOK_PROPERTYARRAY or XTOK_PROPERTYREFERENCE", ct, parm);
 
1130
        }
 
1131
}
 
1132
 
 
1133
static void qualifier(ParserControl *parm, parseUnion *stateUnion)
 
1134
{
 
1135
        parseUnion lvalp;
 
1136
        ct = localLex((parseUnion*)&stateUnion->xtokQualifier, parm);
 
1137
        if(ct == XTOK_QUALIFIER) {
 
1138
                ct = localLex(&lvalp, parm);
 
1139
                dontLex = 1;
 
1140
                if(ct == XTOK_VALUE || ct == XTOK_VALUEARRAY) {
 
1141
                        dontLex = 1;
 
1142
                        qualifierData(parm, (parseUnion*)&lvalp.xtokQualifierData);
 
1143
                        stateUnion->xtokQualifier.data = lvalp.xtokQualifierData;
 
1144
                        if(lvalp.xtokQualifierData.isArray) {
 
1145
                                stateUnion->xtokQualifier.type |= CMPI_ARRAY;
 
1146
                        }
 
1147
                }
 
1148
                ct = localLex((parseUnion*)&stateUnion->xtokQualifier, parm);
 
1149
                if(ct == ZTOK_QUALIFIER) {
 
1150
                }
 
1151
                else {
 
1152
                        parseError("ZTOK_QUALIFIER or XTOK_VALUE or XTOK_VALUEARRAY", ct, parm);
 
1153
                }
 
1154
        }
 
1155
        else {
 
1156
                parseError("XTOK_QUALIFIER", ct, parm);
 
1157
        }
 
1158
}
 
1159
 
 
1160
static void qualifierData(ParserControl *parm, parseUnion *stateUnion)
 
1161
{
 
1162
        parseUnion lvalp;
 
1163
        ct = localLex((parseUnion*)&stateUnion->xtokQualifierData, parm);
 
1164
        if(ct == XTOK_VALUE) {
 
1165
                dontLex = 1;
 
1166
                value(parm, (parseUnion*)&stateUnion->xtokQualifierData.value);
 
1167
                stateUnion->xtokQualifierData.isArray = 0;
 
1168
        }
 
1169
        else if(ct == XTOK_VALUEARRAY) {
 
1170
                dontLex = 1;
 
1171
                valueArray(parm, (parseUnion*)&stateUnion->xtokQualifierData.array);
 
1172
                stateUnion->xtokQualifierData.isArray = 1;
 
1173
        }
 
1174
        else {
 
1175
                parseError("XTOK_VALUE or XTOK_VALUEARRAY", ct, parm);
 
1176
        }
 
1177
}
 
1178
 
 
1179
static void property(ParserControl *parm, parseUnion *stateUnion)
 
1180
{
 
1181
        parseUnion lvalp;
 
1182
        ct = localLex((parseUnion*)&stateUnion->xtokPropertyData, parm);
 
1183
        if(ct == XTOK_PROPERTY) {
 
1184
                ct = localLex(&lvalp, parm);
 
1185
                dontLex = 1;
 
1186
                if(ct == XTOK_QUALIFIER) {
 
1187
                        do {
 
1188
                                dontLex = 1;
 
1189
                                qualifier(parm, (parseUnion*)&lvalp.xtokQualifier);
 
1190
                                addQualifier(parm,&stateUnion->xtokPropertyData.qualifiers,&lvalp.xtokQualifier);
 
1191
                                ct = localLex(&lvalp, parm);
 
1192
                        }
 
1193
                        while(ct == XTOK_QUALIFIER);
 
1194
                        dontLex = 1;
 
1195
                }
 
1196
                ct = localLex(&lvalp, parm);
 
1197
                dontLex = 1;
 
1198
                if(ct == XTOK_VALUE) {
 
1199
                        dontLex = 1;
 
1200
                        value(parm, (parseUnion*)&lvalp.xtokValue);
 
1201
                        stateUnion->xtokPropertyData.value = lvalp.xtokValue;
 
1202
                }
 
1203
                ct = localLex((parseUnion*)&stateUnion->xtokPropertyData, parm);
 
1204
                if(ct == ZTOK_PROPERTY) {
 
1205
                }
 
1206
                else {
 
1207
                        parseError("ZTOK_PROPERTY or XTOK_VALUE or XTOK_QUALIFIER", ct, parm);
 
1208
                }
 
1209
        }
 
1210
        else {
 
1211
                parseError("XTOK_PROPERTY", ct, parm);
 
1212
        }
 
1213
}
 
1214
 
 
1215
static void propertyArray(ParserControl *parm, parseUnion *stateUnion)
 
1216
{
 
1217
        parseUnion lvalp;
 
1218
        ct = localLex((parseUnion*)&stateUnion->xtokPropertyData, parm);
 
1219
        if(ct == XTOK_PROPERTYARRAY) {
 
1220
                ct = localLex(&lvalp, parm);
 
1221
                dontLex = 1;
 
1222
                if(ct == XTOK_QUALIFIER) {
 
1223
                        do {
 
1224
                                dontLex = 1;
 
1225
                                qualifier(parm, (parseUnion*)&lvalp.xtokQualifier);
 
1226
                                addQualifier(parm,&stateUnion->xtokPropertyData.qualifiers,&lvalp.xtokQualifier);
 
1227
                                ct = localLex(&lvalp, parm);
 
1228
                        }
 
1229
                        while(ct == XTOK_QUALIFIER);
 
1230
                        dontLex = 1;
 
1231
                }
 
1232
                ct = localLex(&lvalp, parm);
 
1233
                dontLex = 1;
 
1234
                if(ct == XTOK_VALUEARRAY) {
 
1235
                        dontLex = 1;
 
1236
                        valueArray(parm, (parseUnion*)&lvalp.xtokValueArray);
 
1237
                        stateUnion->xtokPropertyData.array = lvalp.xtokValueArray;
 
1238
                }
 
1239
                ct = localLex((parseUnion*)&stateUnion->xtokPropertyData, parm);
 
1240
                if(ct == ZTOK_PROPERTYARRAY) {
 
1241
                }
 
1242
                else {
 
1243
                        parseError("ZTOK_PROPERTYARRAY or XTOK_VALUEARRAY or XTOK_QUALIFIER", ct, parm);
 
1244
                }
 
1245
        }
 
1246
        else {
 
1247
                parseError("XTOK_PROPERTYARRAY", ct, parm);
 
1248
        }
 
1249
}
 
1250
 
 
1251
static void propertyReference(ParserControl *parm, parseUnion *stateUnion)
 
1252
{
 
1253
        parseUnion lvalp;
 
1254
        ct = localLex((parseUnion*)&stateUnion->xtokPropertyData, parm);
 
1255
        if(ct == XTOK_PROPERTYREFERENCE) {
 
1256
                ct = localLex(&lvalp, parm);
 
1257
                dontLex = 1;
 
1258
                if(ct == XTOK_QUALIFIER) {
 
1259
                        do {
 
1260
                                dontLex = 1;
 
1261
                                qualifier(parm, (parseUnion*)&lvalp.xtokQualifier);
 
1262
                                addQualifier(parm,&stateUnion->xtokPropertyData.qualifiers,&lvalp.xtokQualifier);
 
1263
                                ct = localLex(&lvalp, parm);
 
1264
                        }
 
1265
                        while(ct == XTOK_QUALIFIER);
 
1266
                        dontLex = 1;
 
1267
                }
 
1268
                ct = localLex(&lvalp, parm);
 
1269
                dontLex = 1;
 
1270
                if(ct == XTOK_VALUEREFERENCE) {
 
1271
                        dontLex = 1;
 
1272
                        valueReference(parm, (parseUnion*)&lvalp.xtokValueReference);
 
1273
                        stateUnion->xtokPropertyData.ref = lvalp.xtokValueReference;
 
1274
                }
 
1275
                ct = localLex((parseUnion*)&stateUnion->xtokPropertyData, parm);
 
1276
                if(ct == ZTOK_PROPERTYREFERENCE) {
 
1277
                }
 
1278
                else {
 
1279
                        parseError("ZTOK_PROPERTYREFERENCE or XTOK_VALUEREFERENCE or XTOK_QUALIFIER", ct, parm);
 
1280
                }
 
1281
        }
 
1282
        else {
 
1283
                parseError("XTOK_PROPERTYREFERENCE", ct, parm);
 
1284
        }
 
1285
}
 
1286
 
 
1287
static void instanceName(ParserControl *parm, parseUnion *stateUnion)
 
1288
{
 
1289
        parseUnion lvalp;
 
1290
        ct = localLex((parseUnion*)&stateUnion->xtokInstanceName, parm);
 
1291
        if(ct == XTOK_INSTANCENAME) {
 
1292
                ct = localLex(&lvalp, parm);
 
1293
                dontLex = 1;
 
1294
                if(ct == XTOK_KEYBINDING) {
 
1295
                        do {
 
1296
                                dontLex = 1;
 
1297
                                keyBinding(parm, (parseUnion*)&lvalp.xtokKeyBinding);
 
1298
                                addKeyBinding(parm, &stateUnion->xtokInstanceName.bindings, &lvalp.xtokKeyBinding);
 
1299
                                ct = localLex(&lvalp, parm);
 
1300
                        }
 
1301
                        while(ct == XTOK_KEYBINDING);
 
1302
                        dontLex = 1;
 
1303
                }
 
1304
                ct = localLex((parseUnion*)&stateUnion->xtokInstanceName, parm);
 
1305
                if(ct == ZTOK_INSTANCENAME) {
 
1306
                }
 
1307
                else {
 
1308
                        parseError("ZTOK_INSTANCENAME or XTOK_KEYBINDING", ct, parm);
 
1309
                }
 
1310
        }
 
1311
        else {
 
1312
                parseError("XTOK_INSTANCENAME", ct, parm);
 
1313
        }
 
1314
}
 
1315
 
 
1316
static void keyBinding(ParserControl *parm, parseUnion *stateUnion)
 
1317
{
 
1318
        parseUnion lvalp;
 
1319
        ct = localLex((parseUnion*)&stateUnion->xtokKeyBinding, parm);
 
1320
        if(ct == XTOK_KEYBINDING) {
 
1321
                keyBindingContent(parm, (parseUnion*)&stateUnion->xtokKeyBinding.val);
 
1322
                stateUnion->xtokKeyBinding.type = stateUnion->xtokKeyBinding.val.type;
 
1323
                ct = localLex((parseUnion*)&stateUnion->xtokKeyBinding, parm);
 
1324
                if(ct == ZTOK_KEYBINDING) {
 
1325
                }
 
1326
                else {
 
1327
                        parseError("ZTOK_KEYBINDING", ct, parm);
 
1328
                }
 
1329
        }
 
1330
        else {
 
1331
                parseError("XTOK_KEYBINDING", ct, parm);
 
1332
        }
 
1333
}
 
1334
 
 
1335
static void keyBindingContent(ParserControl *parm, parseUnion *stateUnion)
 
1336
{
 
1337
        parseUnion lvalp;
 
1338
        ct = localLex((parseUnion*)&stateUnion->xtokKeyBindingContent, parm);
 
1339
        if(ct == XTOK_KEYVALUE) {
 
1340
                dontLex = 1;
 
1341
                keyValue(parm, (parseUnion*)&stateUnion->xtokKeyBindingContent.keyValue);
 
1342
                stateUnion->xtokKeyBindingContent.type = stateUnion->xtokKeyBindingContent.keyValue.valueType;
 
1343
        }
 
1344
        else if(ct == XTOK_VALUEREFERENCE) {
 
1345
                dontLex = 1;
 
1346
                valueReference(parm, (parseUnion*)&stateUnion->xtokKeyBindingContent.ref);
 
1347
                stateUnion->xtokKeyBindingContent.type = "ref";
 
1348
        }
 
1349
        else {
 
1350
                parseError("XTOK_KEYVALUE or XTOK_VALUEREFERENCE", ct, parm);
 
1351
        }
 
1352
}
 
1353
 
 
1354
static void keyValue(ParserControl *parm, parseUnion *stateUnion)
 
1355
{
 
1356
        parseUnion lvalp;
 
1357
        ct = localLex((parseUnion*)&stateUnion->xtokKeyValue, parm);
 
1358
        if(ct == XTOK_KEYVALUE) {
 
1359
                ct = localLex((parseUnion*)&stateUnion->xtokKeyValue, parm);
 
1360
                if(ct == ZTOK_KEYVALUE) {
 
1361
                }
 
1362
                else {
 
1363
                        parseError("ZTOK_KEYVALUE", ct, parm);
 
1364
                }
 
1365
        }
 
1366
        else {
 
1367
                parseError("XTOK_KEYVALUE", ct, parm);
 
1368
        }
 
1369
}
 
1370
 
 
1371
static void value(ParserControl *parm, parseUnion *stateUnion)
 
1372
{
 
1373
        parseUnion lvalp;
 
1374
        ct = localLex((parseUnion*)&stateUnion->xtokValue, parm);
 
1375
        if(ct == XTOK_VALUE) {
 
1376
                valueData(parm, (parseUnion*)&stateUnion->xtokValue.data);
 
1377
                stateUnion->xtokValue.type = stateUnion->xtokValue.data.type;
 
1378
                ct = localLex((parseUnion*)&stateUnion->xtokValue, parm);
 
1379
                if(ct == ZTOK_VALUE) {
 
1380
                }
 
1381
                else {
 
1382
                        parseError("ZTOK_VALUE", ct, parm);
 
1383
                }
 
1384
        }
 
1385
        else {
 
1386
                parseError("XTOK_VALUE", ct, parm);
 
1387
        }
 
1388
}
 
1389
 
 
1390
static void valueData(ParserControl *parm, parseUnion *stateUnion)
 
1391
{
 
1392
        parseUnion lvalp;
 
1393
        ct = localLex((parseUnion*)&stateUnion->xtokValueData, parm);
 
1394
        if(ct == ZTOK_VALUE) {
 
1395
                stateUnion->xtokValueData.type=typeValue_charP;
 
1396
                dontLex = 1;
 
1397
        }
 
1398
        else if(ct == XTOK_CDATA) {
 
1399
                stateUnion->xtokValueData.inst = parser_malloc(parm->heap, sizeof(XtokInstance));
 
1400
                instance(parm, (parseUnion*)stateUnion->xtokValueData.inst);
 
1401
                stateUnion->xtokValueData.type=typeValue_Instance;
 
1402
                ct = localLex((parseUnion*)&stateUnion->xtokValueData, parm);
 
1403
                if(ct == ZTOK_CDATA) {
 
1404
                }
 
1405
                else {
 
1406
                        parseError("ZTOK_CDATA", ct, parm);
 
1407
                }
 
1408
        }
 
1409
        else {
 
1410
                parseError("ZTOK_VALUE", ct, parm);
 
1411
        }
 
1412
}
 
1413
 
 
1414
static void valueArray(ParserControl *parm, parseUnion *stateUnion)
 
1415
{
 
1416
        parseUnion lvalp;
 
1417
        ct = localLex((parseUnion*)&stateUnion->xtokValueArray, parm);
 
1418
        if(ct == XTOK_VALUEARRAY) {
 
1419
                ct = localLex(&lvalp, parm);
 
1420
                dontLex = 1;
 
1421
                if(ct == XTOK_VALUE) {
 
1422
                        do {
 
1423
                                dontLex = 1;
 
1424
                                value(parm, (parseUnion*)&lvalp.xtokValue);
 
1425
                                if(stateUnion->xtokValueArray.next >= stateUnion->xtokValueArray.max) {
 
1426
                                        stateUnion->xtokValueArray.max *= 2;
 
1427
                                        stateUnion->xtokValueArray.values = (char**)parser_realloc(parm->heap, stateUnion->xtokValueArray.values, sizeof(char*) * stateUnion->xtokValueArray.max);
 
1428
                                }
 
1429
                                stateUnion->xtokValueArray.values[stateUnion->xtokValueArray.next++] = lvalp.xtokValue.data.value;
 
1430
                                ct = localLex(&lvalp, parm);
 
1431
                        }
 
1432
                        while(ct == XTOK_VALUE);
 
1433
                        dontLex = 1;
 
1434
                }
 
1435
                ct = localLex((parseUnion*)&stateUnion->xtokValueArray, parm);
 
1436
                if(ct == ZTOK_VALUEARRAY) {
 
1437
                }
 
1438
                else {
 
1439
                        parseError("ZTOK_VALUEARRAY or XTOK_VALUE", ct, parm);
 
1440
                }
 
1441
        }
 
1442
        else {
 
1443
                parseError("XTOK_VALUEARRAY", ct, parm);
 
1444
        }
 
1445
}
 
1446
 
 
1447
static void valueRefArray(ParserControl *parm, parseUnion *stateUnion)
 
1448
{
 
1449
        parseUnion lvalp;
 
1450
        ct = localLex((parseUnion*)&stateUnion->xtokValueRefArray, parm);
 
1451
        if(ct == XTOK_VALUEREFARRAY) {
 
1452
                ct = localLex(&lvalp, parm);
 
1453
                dontLex = 1;
 
1454
                if(ct == XTOK_VALUEREFERENCE) {
 
1455
                        do {
 
1456
                                dontLex = 1;
 
1457
                                valueReference(parm, (parseUnion*)&lvalp.xtokValueReference);
 
1458
                                if(stateUnion->xtokValueRefArray.next >= stateUnion->xtokValueRefArray.max) {
 
1459
                                        stateUnion->xtokValueRefArray.max *= 2;
 
1460
                                        stateUnion->xtokValueRefArray.values = (XtokValueReference*)parser_realloc(parm->heap, stateUnion->xtokValueRefArray.values, sizeof(XtokValueReference) * stateUnion->xtokValueRefArray.max);
 
1461
                                }
 
1462
                                stateUnion->xtokValueRefArray.values[stateUnion->xtokValueRefArray.next++] = lvalp.xtokValueReference;
 
1463
                                ct = localLex(&lvalp, parm);
 
1464
                        }
 
1465
                        while(ct == XTOK_VALUEREFERENCE);
 
1466
                        dontLex = 1;
 
1467
                }
 
1468
                ct = localLex((parseUnion*)&stateUnion->xtokValueRefArray, parm);
 
1469
                if(ct == ZTOK_VALUEREFARRAY) {
 
1470
                }
 
1471
                else {
 
1472
                        parseError("ZTOK_VALUEREFARRAY or XTOK_VALUEREFERENCE", ct, parm);
 
1473
                }
 
1474
        }
 
1475
        else {
 
1476
                parseError("XTOK_VALUEREFARRAY", ct, parm);
 
1477
        }
 
1478
}
 
1479
 
 
1480
static void valueReference(ParserControl *parm, parseUnion *stateUnion)
 
1481
{
 
1482
        parseUnion lvalp;
 
1483
        ct = localLex((parseUnion*)&stateUnion->xtokValueReference, parm);
 
1484
        if(ct == XTOK_VALUEREFERENCE) {
 
1485
                valueReferenceData(parm, (parseUnion*)&stateUnion->xtokValueReference.data);
 
1486
                stateUnion->xtokValueReference.type = stateUnion->xtokValueReference.data.type;
 
1487
                ct = localLex((parseUnion*)&stateUnion->xtokValueReference, parm);
 
1488
                if(ct == ZTOK_VALUEREFERENCE) {
 
1489
                }
 
1490
                else {
 
1491
                        parseError("ZTOK_VALUEREFERENCE", ct, parm);
 
1492
                }
 
1493
        }
 
1494
        else {
 
1495
                parseError("XTOK_VALUEREFERENCE", ct, parm);
 
1496
        }
 
1497
}
 
1498
 
 
1499
static void valueReferenceData(ParserControl *parm, parseUnion *stateUnion)
 
1500
{
 
1501
        parseUnion lvalp;
 
1502
        ct = localLex((parseUnion*)&stateUnion->xtokValueReferenceData, parm);
 
1503
        if(ct == XTOK_INSTANCEPATH) {
 
1504
                dontLex = 1;
 
1505
                instancePath(parm, (parseUnion*)&stateUnion->xtokValueReferenceData.instancePath);
 
1506
                stateUnion->xtokValueReferenceData.type = typeValRef_InstancePath;
 
1507
        }
 
1508
        else if(ct == XTOK_LOCALINSTANCEPATH) {
 
1509
                dontLex = 1;
 
1510
                localInstancePath(parm, (parseUnion*)&stateUnion->xtokValueReferenceData.localInstancePath);
 
1511
                stateUnion->xtokValueReferenceData.type = typeValRef_LocalInstancePath;
 
1512
        }
 
1513
        else if(ct == XTOK_INSTANCENAME) {
 
1514
                dontLex = 1;
 
1515
                instanceName(parm, (parseUnion*)&stateUnion->xtokValueReferenceData.instanceName);
 
1516
                stateUnion->xtokValueReferenceData.type = typeValRef_InstanceName;
 
1517
        }
 
1518
        else {
 
1519
                parseError("XTOK_INSTANCEPATH or XTOK_LOCALINSTANCEPATH or XTOK_INSTANCENAME", ct, parm);
 
1520
        }
 
1521
}
 
1522