ComplexType.cc 83.3 KB
Newer Older
Elemer Lelik's avatar
Elemer Lelik committed
1
/******************************************************************************
Lenard Nagy's avatar
Lenard Nagy committed
2
 * Copyright (c) 2000-2017 Ericsson Telecom AB
Elemer Lelik's avatar
Elemer Lelik committed
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   Balasko, Jeno
 *   Beres, Szabolcs
 *   Godar, Marton
 *   Ormandi, Matyas
 *   Raduly, Csaba
 *   Szabo, Bence Janos
 *
 ******************************************************************************/
Elemer Lelik's avatar
Elemer Lelik committed
17
18
19
20
21
22
#include "ComplexType.hh"

#include "GeneralFunctions.hh"
#include "XMLParser.hh"
#include "TTCN3Module.hh"
#include "TTCN3ModuleInventory.hh"
Elemer Lelik's avatar
Elemer Lelik committed
23
#include "Annotation.hh"
24
#include "Constant.hh"
Elemer Lelik's avatar
Elemer Lelik committed
25
26
27
28

#include <assert.h>

ComplexType::ComplexType(XMLParser * a_parser, TTCN3Module * a_module, ConstructType a_construct)
Elemer Lelik's avatar
Elemer Lelik committed
29
30
31
32
33
: SimpleType(a_parser, a_module, a_construct)
, top(true)
, nillable(false)
, enumerated(false)
, embed(false)
Elemer Lelik's avatar
Elemer Lelik committed
34
, with_union(false)
Elemer Lelik's avatar
Elemer Lelik committed
35
36
, first_child(false)
, fromAll(false)
37
38
39
, listPrint(false)
, listMinOccurs(1)
, listMaxOccurs(1)
Elemer Lelik's avatar
Elemer Lelik committed
40
41
42
43
44
45
46
47
48
, max_alt(0)
, skipback(0)
, lastType()
, actualPath(empty_string)
, actfield(this)
, nameDep(NULL)
, nillable_field(NULL)
, basefield(NULL)
, cmode(CT_undefined_mode)
Elemer Lelik's avatar
Elemer Lelik committed
49
, resolved(No)
Elemer Lelik's avatar
Elemer Lelik committed
50
, parentTypeSubsGroup(NULL)
Elemer Lelik's avatar
Elemer Lelik committed
51
52
53
54
55
, complexfields()
, attribfields()
, enumfields()
, tagNames() {
  xsdtype = n_complexType;
Elemer Lelik's avatar
Elemer Lelik committed
56
57
}

Elemer Lelik's avatar
Elemer Lelik committed
58
59
60
61
62
63
ComplexType::ComplexType(ComplexType & other)
: SimpleType(other)
, top(other.top)
, nillable(other.nillable)
, enumerated(other.enumerated)
, embed(other.embed)
Elemer Lelik's avatar
Elemer Lelik committed
64
, with_union(other.with_union)
Elemer Lelik's avatar
Elemer Lelik committed
65
66
, first_child(other.first_child)
, fromAll(other.fromAll)
67
68
69
, listPrint(other.listPrint)
, listMinOccurs(other.listMinOccurs)
, listMaxOccurs(other.listMaxOccurs)
Elemer Lelik's avatar
Elemer Lelik committed
70
71
72
73
74
75
76
77
78
, max_alt(other.max_alt)
, skipback(other.skipback)
, lastType(other.lastType)
, actualPath(other.actualPath)
, actfield(this)
, nameDep(other.nameDep)
, nillable_field(NULL)
, basefield(NULL)
, cmode(other.cmode)
Elemer Lelik's avatar
Elemer Lelik committed
79
80
, resolved(other.resolved)
, parentTypeSubsGroup(other.parentTypeSubsGroup) {
Elemer Lelik's avatar
Elemer Lelik committed
81
82
83
84
85
86
87
88
89
90
91
92
93
94
  type.originalValueWoPrefix = other.type.originalValueWoPrefix;
  for (List<AttributeType*>::iterator attr = other.attribfields.begin(); attr; attr = attr->Next) {
    attribfields.push_back(new AttributeType(*attr->Data));
    attribfields.back()->parent = this;
  }

  for (List<ComplexType*>::iterator field = other.complexfields.begin(); field; field = field->Next) {
    complexfields.push_back(new ComplexType(*field->Data));
    complexfields.back()->parent = this;
    if(field->Data == other.basefield){
      basefield = complexfields.back();
    }else if(field->Data == other.nillable_field){
      nillable_field = complexfields.back();
    }
Elemer Lelik's avatar
Elemer Lelik committed
95
  }
Elemer Lelik's avatar
Elemer Lelik committed
96
97
98
99
100
101
102
103
104

  if (other.nameDep != NULL) {
    SimpleType* dep = other.nameDep;
    if(dep->getSubstitution() != NULL){
      dep->getSubstitution()->addToNameDepList(this);
      nameDep = dep->getSubstitution();
    }else {
      other.nameDep->addToNameDepList(this);
    }
Elemer Lelik's avatar
Elemer Lelik committed
105
106
107
  }
}

Elemer Lelik's avatar
Elemer Lelik committed
108
109
110
111
112
113
ComplexType::ComplexType(ComplexType * other)
: SimpleType(other->getParser(), other->getModule(), c_unknown)
, top(false)
, nillable(false)
, enumerated(false)
, embed(false)
Elemer Lelik's avatar
Elemer Lelik committed
114
, with_union(false)
Elemer Lelik's avatar
Elemer Lelik committed
115
116
, first_child(false)
, fromAll(false)
117
118
119
, listPrint(false)
, listMinOccurs(1)
, listMaxOccurs(1)
Elemer Lelik's avatar
Elemer Lelik committed
120
121
122
123
124
125
126
127
128
, max_alt(0)
, skipback(0)
, lastType()
, actualPath(empty_string)
, actfield(this)
, nameDep(NULL)
, nillable_field(NULL)
, basefield(NULL)
, cmode(CT_undefined_mode)
Elemer Lelik's avatar
Elemer Lelik committed
129
, resolved(No)
Elemer Lelik's avatar
Elemer Lelik committed
130
, parentTypeSubsGroup(NULL)
Elemer Lelik's avatar
Elemer Lelik committed
131
132
133
134
135
136
137
138
, complexfields()
, attribfields()
, enumfields()
, tagNames() {
  xsdtype = n_complexType;
  parent = other;
  outside_reference = ReferenceData();
}
Elemer Lelik's avatar
Elemer Lelik committed
139

Elemer Lelik's avatar
Elemer Lelik committed
140
141
142
143
144
145
146
147
148
ComplexType::ComplexType(const SimpleType & other, CT_fromST c)
: SimpleType(other)
, top(true)
, nillable(false)
, enumerated(false)
, embed(false)
, with_union(false)
, first_child(false)
, fromAll(false)
149
150
151
, listPrint(false)
, listMinOccurs(1)
, listMaxOccurs(1)
Elemer Lelik's avatar
Elemer Lelik committed
152
153
154
155
156
157
158
159
160
161
, max_alt(0)
, skipback(0)
, lastType()
, actualPath(empty_string)
, actfield(this)
, nameDep(NULL)
, nillable_field(NULL)
, basefield(NULL)
, cmode(CT_simpletype_mode)
, resolved(No)
Elemer Lelik's avatar
Elemer Lelik committed
162
, parentTypeSubsGroup(NULL)
Elemer Lelik's avatar
Elemer Lelik committed
163
164
165
166
167
, complexfields()
, attribfields()
, enumfields()
, tagNames() {

Elemer Lelik's avatar
Elemer Lelik committed
168
  if(c != fromTagSubstitution && c != fromTypeSubstitution){
Elemer Lelik's avatar
Elemer Lelik committed
169
170
    module->replaceLastMainType(this);
    module->setActualXsdConstruct(c_complexType);
Elemer Lelik's avatar
Elemer Lelik committed
171
  }
Elemer Lelik's avatar
Elemer Lelik committed
172
  construct = c_complexType;
Elemer Lelik's avatar
Elemer Lelik committed
173

Elemer Lelik's avatar
Elemer Lelik committed
174
175
  switch (c) {
    case fromTagUnion:
176
      type.upload(Mstring("union"), false);
Elemer Lelik's avatar
Elemer Lelik committed
177
178
179
180
181
      with_union = true;
      xsdtype = n_union;
      break;
    case fromTagNillable:
      addVariant(V_useNil);
182
      type.upload(Mstring("record"), false);
Elemer Lelik's avatar
Elemer Lelik committed
183
184
      break;
    case fromTagComplexType:
185
      type.upload(Mstring("record"), false);
Elemer Lelik's avatar
Elemer Lelik committed
186
187
      xsdtype = n_complexType;
      break;
Elemer Lelik's avatar
Elemer Lelik committed
188
    case fromTagSubstitution:
189
      type.upload(Mstring("union"), false);
Elemer Lelik's avatar
Elemer Lelik committed
190
191
192
193
      name.upload(getName().originalValueWoPrefix + Mstring("_group"));
      xsdtype = n_union;
      subsGroup = this;
      variant.clear();
Elemer Lelik's avatar
Elemer Lelik committed
194
      hidden_variant.clear();
Elemer Lelik's avatar
Elemer Lelik committed
195
196
197
198
199
200
      enumeration.modified = false;
      value.modified = false;
      pattern.modified = false;
      length.modified = false;
      whitespace.modified = false;
      break;
Elemer Lelik's avatar
Elemer Lelik committed
201
    case fromTypeSubstitution:
202
      type.upload(Mstring("union"), false);
Elemer Lelik's avatar
Elemer Lelik committed
203
204
205
206
207
208
209
210
211
212
213
      name.upload(getName().originalValueWoPrefix + Mstring("_derivations"));
      xsdtype = n_union;
      substitutionGroup = empty_string;
      typeSubsGroup = this;
      variant.clear();
      hidden_variant.clear();
      enumeration.modified = false;
      value.modified = false;
      pattern.modified = false;
      length.modified = false;
      whitespace.modified = false;
Elemer Lelik's avatar
Elemer Lelik committed
214
215
216
  }
}

Elemer Lelik's avatar
Elemer Lelik committed
217
218
219
220
221
222
ComplexType::~ComplexType() {
  for (List<ComplexType*>::iterator field = complexfields.begin(); field; field = field->Next) {
    delete field->Data;
    field->Data = NULL;
  }
  complexfields.clear();
Elemer Lelik's avatar
Elemer Lelik committed
223

Elemer Lelik's avatar
Elemer Lelik committed
224
225
226
227
228
  for (List<AttributeType*>::iterator field = attribfields.begin(); field; field = field->Next) {
    delete field->Data;
    field->Data = NULL;
  }
  attribfields.clear();
Elemer Lelik's avatar
Elemer Lelik committed
229
230
}

Elemer Lelik's avatar
Elemer Lelik committed
231
232
233
234
235
236
237
void ComplexType::loadWithValues() {
  //Find the last field where the tag is found
  if (this != actfield) {
    actfield->loadWithValues();
    return;
  }
  
Elemer Lelik's avatar
Elemer Lelik committed
238
  const XMLParser::TagAttributes & atts = parser->getActualTagAttributes();
Elemer Lelik's avatar
Elemer Lelik committed
239
240
241
242
243
244
  
  switch (parser->getActualTagName()) {
    case n_sequence:
      if (!top && xsdtype != n_sequence && xsdtype != n_complexType && xsdtype != n_extension && xsdtype != n_restriction && xsdtype != n_element) {
        //Create new record
        ComplexType * rec = new ComplexType(this);
245
        rec->type.upload(Mstring("record"), false);
Elemer Lelik's avatar
Elemer Lelik committed
246
247
248
249
250
251
252
253
254
255
256
        rec->name.upload(Mstring("sequence"));
        rec->addVariant(V_untagged);
        rec->setMinMaxOccurs(atts.minOccurs, atts.maxOccurs);
        rec->setXsdtype(n_sequence);
        complexfields.push_back(rec);
        actfield = rec;
      } else {
        //Do not create new record, it is an embedded sequence
        if (xsdtype == n_sequence && atts.minOccurs == 1 && atts.maxOccurs == 1) {
          skipback += 1;
        }
257
        type.upload(Mstring("record"), false);
Elemer Lelik's avatar
Elemer Lelik committed
258
259
260
        xsdtype = n_sequence;
        setMinMaxOccurs(atts.minOccurs, atts.maxOccurs);
      }
Elemer Lelik's avatar
Elemer Lelik committed
261
      break;
Elemer Lelik's avatar
Elemer Lelik committed
262
263
264
265
    case n_choice:
      if (!top || xsdtype != n_group) {
        //Create new union field
        ComplexType * choice = new ComplexType(this);
266
        choice->type.upload(Mstring("union"), false);
Elemer Lelik's avatar
Elemer Lelik committed
267
268
269
270
271
272
273
274
        choice->name.upload(Mstring("choice"));
        choice->setXsdtype(n_choice);
        choice->addVariant(V_untagged);
        choice->setMinMaxOccurs(atts.minOccurs, atts.maxOccurs);
        actfield = choice;
        complexfields.push_back(choice);
      } else {
        xsdtype = n_choice;
275
        type.upload(Mstring("union"), false);
Elemer Lelik's avatar
Elemer Lelik committed
276
277
278
      }
      break;
    case n_all:
Elemer Lelik's avatar
Elemer Lelik committed
279
    {
Elemer Lelik's avatar
Elemer Lelik committed
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
      //Create the record of enumerated field
      xsdtype = n_all;
      ComplexType * enumField = new ComplexType(this);
      enumField->setTypeValue(Mstring("enumerated"));
      enumField->setNameValue(Mstring("order"));
      enumField->setBuiltInBase(Mstring("string"));
      enumField->enumerated = true;
      enumField->setMinMaxOccurs(0, ULLONG_MAX, false);
      setMinMaxOccurs(atts.minOccurs, atts.maxOccurs);
      addVariant(V_useOrder);
      complexfields.push_back(enumField);
      if (atts.minOccurs == 0) {
        isOptional = true;
      }
      break;
    }
    case n_restriction:
      mode = restrictionMode;
      //If it is an xsd:union then call SimpleType::loadWithValues
299
      if (parent != NULL && parent->with_union && parent->hasVariant(Mstring("useUnion"))) {
Elemer Lelik's avatar
Elemer Lelik committed
300
301
302
303
304
305
306
307
308
309
        SimpleType::loadWithValues();
        break;
      }
      if (cmode == CT_simpletype_mode) {
        //if it is from a SimpleType, then create a base field
        ComplexType * f = new ComplexType(this);
        f->name.upload(Mstring("base"));
        f->type.upload(atts.base);
        f->setReference(atts.base);
        f->addVariant(V_untagged);
310
        f->mode = restrictionMode;
Elemer Lelik's avatar
Elemer Lelik committed
311
312
313
        complexfields.push_back(f);
        basefield = f;
        actfield = f;
314
315
316
317
318
319
        
        // If it is a restriction of a list, then no new basefield will be 
        // present, to we apply the references to the parent.
        if(parent != NULL && parent->inList) {
          parent->applyReference(*f, true);
        }
Elemer Lelik's avatar
Elemer Lelik committed
320
321
322
323
324
325
326
327
328
329
330
331
332
333
      } else if (cmode == CT_complextype_mode) {
        setReference(atts.base);
        xsdtype = n_restriction;
      }
      break;
    case n_extension:
      mode = extensionMode;
      if (cmode == CT_simpletype_mode) {
        //if it is from a SimpleType, then create a base field
        ComplexType * f = new ComplexType(this);
        f->name.upload(Mstring("base"));
        f->type.upload(atts.base);
        f->setReference(atts.base);
        f->addVariant(V_untagged);
334
        f->mode = extensionMode;
Elemer Lelik's avatar
Elemer Lelik committed
335
336
337
338
339
340
341
342
343
        complexfields.push_back(f);
        basefield = f;
        actfield = f;
      } else if (cmode == CT_complextype_mode) {
        setReference(atts.base);
        xsdtype = n_extension;
      }
      break;
    case n_element:
Elemer Lelik's avatar
Elemer Lelik committed
344
    {
Elemer Lelik's avatar
Elemer Lelik committed
345
346
347
348
349
      if (atts.nillable) {
        if(cmode == CT_simpletype_mode){
          //If a simple top level element is nillable
          ComplexType * nilrec = new ComplexType(this);
          if (atts.type.empty()) {
350
            nilrec->type.upload(Mstring("record"), false);
Elemer Lelik's avatar
Elemer Lelik committed
351
352
353
354
355
356
357
358
          } else {
            nilrec->type.upload(atts.type);
          }
          nilrec->name.upload(Mstring("content"));
          nilrec->isOptional = true;
          nilrec->nillable = true;
          setMinMaxOccurs(atts.minOccurs, atts.maxOccurs);
          complexfields.push_back(nilrec);
359
          type.upload(Mstring("record"), false);
Elemer Lelik's avatar
Elemer Lelik committed
360
361
362
363
364
365
366
367
          name.upload(atts.name);
          actfield = nilrec;
          nillable_field = nilrec;
        } else {
          //From a complexType element is nillable
          ComplexType * record = new ComplexType(this);
          ComplexType * nilrec = new ComplexType(record);
          if (atts.type.empty()) {
368
            nilrec->type.upload(Mstring("record"), false);
Elemer Lelik's avatar
Elemer Lelik committed
369
370
371
372
          } else {
            nilrec->type.upload(atts.type);
          }
          record->name.upload(atts.name);
373
          record->type.upload(Mstring("record"), false);
Elemer Lelik's avatar
Elemer Lelik committed
374
375
376
377
378
379
380
381
382
383
384
          record->complexfields.push_back(nilrec);
          record->addVariant(V_useNil);
          record->nillable_field = nilrec;
          record->setMinMaxOccurs(atts.minOccurs, atts.maxOccurs);

          nilrec->name.upload(Mstring("content"));
          nilrec->nillable = true;
          nilrec->isOptional = true;
          nilrec->tagNames.push_back(parser->getActualTagName());
          complexfields.push_back(record);
          actfield = nilrec;
Elemer Lelik's avatar
Elemer Lelik committed
385
        }
Elemer Lelik's avatar
Elemer Lelik committed
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
      }else {
        //It is a simple element
        ComplexType* c = new ComplexType(this);
        c->setXsdtype(n_element);
        c->type.upload(atts.type);
        c->name.upload(atts.name);
        c->setReference(atts.type);
        c->setMinMaxOccurs(atts.minOccurs, atts.maxOccurs);
        c->applyDefaultAttribute(atts.default_);
        c->applyFixedAttribute(atts.fixed);
        c->setElementFormAs(atts.form);
        if (atts.ref.empty()) {
          c->setReference(atts.type);
        } else {
          c->applyRefAttribute(atts.ref);
          c->name.upload(atts.ref.getValueWithoutPrefix(':'));
          c->type.upload(atts.ref);
Elemer Lelik's avatar
Elemer Lelik committed
403
        }
Elemer Lelik's avatar
Elemer Lelik committed
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
        c->applySubstitionGroupAttribute(atts.substitionGroup);
        c->applyBlockAttribute(atts.block);
        actfield = c;

        //Inside all have some special conditions
        if (xsdtype == n_all) {
          if (atts.minOccurs > 1) {
            printError(getModule()->getSchemaname(), name.convertedValue,
              Mstring("Inside <all>, minOccurs must be 0 or 1"));
            TTCN3ModuleInventory::incrNumErrors();
          }
          if (atts.maxOccurs != 1) {
            printError(getModule()->getSchemaname(), name.convertedValue,
              Mstring("Inside <all>, maxOccurs must be 1"));
            TTCN3ModuleInventory::incrNumErrors();
          }
          c->fromAll = true;
          complexfields.push_back(c);
          if (isOptional) {
            c->isOptional = true;
          }
        } else {
          complexfields.push_back(c);
Elemer Lelik's avatar
Elemer Lelik committed
427
428
429
430
        }
      }
      break;
    }
Elemer Lelik's avatar
Elemer Lelik committed
431
    case n_attribute:
Elemer Lelik's avatar
Elemer Lelik committed
432
    {
Elemer Lelik's avatar
Elemer Lelik committed
433
434
435
436
437
438
439
440
441
442
443
444
445
      AttributeType * attribute = new AttributeType(this);
      attribute->addVariant(V_attribute);
      attribute->applyMinMaxOccursAttribute(0, 1);
      attribute->setXsdtype(n_attribute);
      attribute->setUseVal(atts.use);
      attribute->setAttributeFormAs(atts.form);
      lastType = n_attribute;
      if (atts.ref.empty()) {
        attribute->setNameOfField(atts.name);
        attribute->setTypeOfField(atts.type);
        attribute->setReference(atts.type, true);
      } else {
        attribute->applyRefAttribute(atts.ref);
Elemer Lelik's avatar
Elemer Lelik committed
446
      }
447
448
      attribute->applyDefaultAttribute(atts.default_);
      attribute->applyFixedAttribute(atts.fixed);
Elemer Lelik's avatar
Elemer Lelik committed
449
450
451
452
453
454
455
456
457
458
459
460
461
      actfield = attribute;
      
      //In case of nillable parent it is difficult...
      if (nillable && parent != NULL) {
        parent->attribfields.push_back(attribute);
        attribute->parent = parent;
      } else if (nillable && !complexfields.empty() && parent == NULL) {
        complexfields.back()->attribfields.push_back(attribute);
      } else if (parent != NULL && (parent->mode == extensionMode || parent->mode == restrictionMode) && name.convertedValue == Mstring("base")) {
        parent->attribfields.push_back(attribute);
        attribute->parent = parent;
      } else {
        attribfields.push_back(attribute);
Elemer Lelik's avatar
Elemer Lelik committed
462
      }
Elemer Lelik's avatar
Elemer Lelik committed
463
      break;
Elemer Lelik's avatar
Elemer Lelik committed
464
    }
Elemer Lelik's avatar
Elemer Lelik committed
465
466
467
468
    case n_any:
    {
      ComplexType * any = new ComplexType(this);
      any->name.upload(Mstring("elem"));
469
      any->type.upload(Mstring("string"), false);
Elemer Lelik's avatar
Elemer Lelik committed
470
471
472
473
474
      any->applyNamespaceAttribute(V_anyElement, atts.namespace_);
      any->setMinMaxOccurs(atts.minOccurs, atts.maxOccurs);
      any->setXsdtype(n_any);
      complexfields.push_back(any);
      break;
Elemer Lelik's avatar
Elemer Lelik committed
475
    }
Elemer Lelik's avatar
Elemer Lelik committed
476
    case n_anyAttribute:
Elemer Lelik's avatar
Elemer Lelik committed
477
    {
Elemer Lelik's avatar
Elemer Lelik committed
478
479
480
      AttributeType * anyattr = new AttributeType(this);
      anyattr->setXsdtype(n_anyAttribute);
      anyattr->setNameOfField(Mstring("attr"));
481
      anyattr->setTypeValue(Mstring("string"));
Elemer Lelik's avatar
Elemer Lelik committed
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
      anyattr->setToAnyAttribute();
      anyattr->applyMinMaxOccursAttribute(0, ULLONG_MAX);
      anyattr->addNameSpaceAttribute(atts.namespace_);
      actfield = anyattr;

      //In case of nillable parent it is difficult...
      if (nillable && parent != NULL) {
        parent->attribfields.push_back(anyattr);
        anyattr->parent = parent;
      } else if (nillable && !complexfields.empty() && parent == NULL) {
        complexfields.back()->attribfields.push_back(anyattr);
      } else if (parent != NULL && (parent->mode == extensionMode || parent->mode == restrictionMode) && name.convertedValue == Mstring("base")) {
        parent->attribfields.push_back(anyattr);
        anyattr->parent = parent;
      } else {
        attribfields.push_back(anyattr);
Elemer Lelik's avatar
Elemer Lelik committed
498
      }
Elemer Lelik's avatar
Elemer Lelik committed
499
      break;
Elemer Lelik's avatar
Elemer Lelik committed
500
    }
Elemer Lelik's avatar
Elemer Lelik committed
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
    case n_attributeGroup:
      if (!atts.ref.empty()) {
        ComplexType * g = new ComplexType(this);
        g->setXsdtype(n_attributeGroup);
        g->setReference(atts.ref);
        complexfields.push_back(g);
        actfield = g;
      } else {
        xsdtype = n_attributeGroup;
        name.upload(Mstring(atts.name));
        setInvisible();
      }
      break;
    case n_group:
      if (atts.ref.empty()) {
        //It is a definition
        xsdtype = n_group;
        name.upload(atts.name);
      } else {
        //It is a reference
        ComplexType* group = new ComplexType(this);
        group->setXsdtype(n_group);
        group->name.upload(atts.name);
        group->setReference(Mstring(atts.ref));
        group->setMinMaxOccurs(atts.minOccurs, atts.maxOccurs);
        complexfields.push_back(group);
        actfield = group;
      }
      break;
    case n_union:
Elemer Lelik's avatar
Elemer Lelik committed
531
    {
Elemer Lelik's avatar
Elemer Lelik committed
532
533
      with_union = true;
      xsdtype = n_union;
534
      type.upload(Mstring("union"), false);
Elemer Lelik's avatar
Elemer Lelik committed
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
      addVariant(V_useUnion);
      if (!atts.memberTypes.empty()) {
        List<Mstring> types;
        //Get the union values
        expstring_t valueToSplitIntoTokens = mcopystr(atts.memberTypes.c_str());
        char * token;
        token = strtok(valueToSplitIntoTokens, " ");
        while (token != NULL) {
          types.push_back(Mstring(token));
          token = strtok(NULL, " ");
        }
        Free(valueToSplitIntoTokens);
        
        //Create the union elements and push into the container
        for (List<Mstring>::iterator memberType = types.begin(); memberType; memberType = memberType->Next) {
          Mstring tmp_name = memberType->Data.getValueWithoutPrefix(':');
          ComplexType * f = new ComplexType(this);
          f->name.upload(tmp_name);
          f->type.upload(memberType->Data);
          f->setXsdtype(n_simpleType);
          f->setReference(memberType->Data);
          complexfields.push_back(f);
        }
Elemer Lelik's avatar
Elemer Lelik committed
558
      }
Elemer Lelik's avatar
Elemer Lelik committed
559
      break;
Elemer Lelik's avatar
Elemer Lelik committed
560
    }
Elemer Lelik's avatar
Elemer Lelik committed
561
562
    case n_simpleType:
    case n_simpleContent:
Elemer Lelik's avatar
Elemer Lelik committed
563
    {
Elemer Lelik's avatar
Elemer Lelik committed
564
565
      xsdtype = parser->getActualTagName();
      cmode = CT_simpletype_mode;
566
      if (with_union && hasVariant(Mstring("useUnion"))) {
567
        Mstring fieldname;
Elemer Lelik's avatar
Elemer Lelik committed
568
569
570
        if (max_alt == 0) {
          fieldname = Mstring("alt_");
        } else {
571
572
573
          expstring_t new_name = mprintf("alt_%d", max_alt);
          fieldname = new_name;
          Free(new_name);
Elemer Lelik's avatar
Elemer Lelik committed
574
575
576
577
578
579
580
581
        }
        max_alt++;
        ComplexType * field = new ComplexType(this);
        field->name.upload(fieldname);
        field->setXsdtype(n_simpleType);
        field->addVariant(V_nameAs, empty_string, true);
        complexfields.push_back(field);
        actfield = field;
Elemer Lelik's avatar
Elemer Lelik committed
582
      }
Elemer Lelik's avatar
Elemer Lelik committed
583
      break;
Elemer Lelik's avatar
Elemer Lelik committed
584
    }
Elemer Lelik's avatar
Elemer Lelik committed
585
586
    case n_complexType:
      name.upload(atts.name);
587
      type.upload(Mstring("record"), false);
Elemer Lelik's avatar
Elemer Lelik committed
588
589
590
591
592
593
594
595
596
597
      applyAbstractAttribute(atts.abstract);
      applySubstitionGroupAttribute(atts.substitionGroup);
      applyBlockAttribute(atts.block);
      // fall through
    case n_complexContent:
      tagNames.push_back(parser->getActualTagName());
      cmode = CT_complextype_mode;
      if (atts.mixed) {
        ComplexType * mixed = new ComplexType(this);
        mixed->name.upload(Mstring("embed_values"));
598
        mixed->type.upload(Mstring("string"), false);
Elemer Lelik's avatar
Elemer Lelik committed
599
600
601
602
603
604
605
        mixed->setMinMaxOccurs(0, ULLONG_MAX, false);
        mixed->embed = true;
        complexfields.push_back(mixed);
        addVariant(V_embedValues);
      }
      break;
    case n_list:
ebensza's avatar
ebensza committed
606
      if (parent != NULL && parent->basefield == this) {
607
608
609
610
611
612
613
614
615
616
617
618
619
620
        if (parent->getMaxOccurs() == 1) { // optional or minOccurs = maxOccurs = 1
          if (parent->getMinOccurs() == 0) {
            parent->isOptional = true;
            if (parent->parent != NULL && parent->parent->getXsdtype() == n_choice) {
              parent->listPrint = true;
              parent->listMinOccurs = parent->getMinOccurs();
              parent->listMaxOccurs = parent->getMaxOccurs();
            }
          }
        } else if (parent->parent != NULL){
          parent->listPrint = true;
          parent->listMinOccurs = parent->getMinOccurs();
          parent->listMaxOccurs = parent->getMaxOccurs();
        }
ebensza's avatar
ebensza committed
621
        parent->basefield = NULL;
622
        parent->SimpleType::loadWithValues();
ebensza's avatar
ebensza committed
623
        setInvisible();
624
      } else if(parent != NULL) {
625
626
627
628
629
630
631
632
633
634
635
636
637
638
        if (getMaxOccurs() == 1) { // optional or minOccurs = maxOccurs = 1
          if (getMinOccurs() == 0) {
            isOptional = true;
            if (parent->getXsdtype() == n_choice) {
              listPrint = true;
              listMinOccurs = getMinOccurs();
              listMaxOccurs = getMaxOccurs();
            }
          }
        } else {
          listPrint = true;
          listMinOccurs = getMinOccurs();
          listMaxOccurs = getMaxOccurs();
        }
639
        SimpleType::loadWithValues();
ebensza's avatar
ebensza committed
640
      }
641
      break;
Elemer Lelik's avatar
Elemer Lelik committed
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
    case n_length:
    case n_minLength:
    case n_maxLength:
    case n_pattern:
    case n_enumeration:
    case n_whiteSpace:
    case n_minInclusive:
    case n_maxInclusive:
    case n_minExclusive:
    case n_maxExclusive:
    case n_totalDigits:
    case n_fractionDigits:
      SimpleType::loadWithValues();
      break;
    case n_label:
      addComment(Mstring("LABEL:"));
      break;
    case n_definition:
      addComment(Mstring("DEFINITION:"));
      break;
    default:
      break;
Elemer Lelik's avatar
Elemer Lelik committed
664
665
666
667
  }
}

// called from endelementHandler
Elemer Lelik's avatar
Elemer Lelik committed
668
669
670
671
672
673
674
void ComplexType::modifyValues() {
  if (this != actfield) {
    actfield->modifyValues();
    return;
  }
  if (xsdtype == n_sequence) {
    skipback = skipback - 1;
Elemer Lelik's avatar
Elemer Lelik committed
675
676
  }

ebensza's avatar
ebensza committed
677
678
  if ( parent != NULL && 
      (xsdtype == n_element || 
Elemer Lelik's avatar
Elemer Lelik committed
679
680
681
682
683
684
685
686
687
688
       xsdtype == n_complexType || 
       xsdtype == n_complexContent || 
       xsdtype == n_all || 
       xsdtype == n_attribute || 
       xsdtype == n_anyAttribute ||
       xsdtype == n_choice || 
       xsdtype == n_group || 
       xsdtype == n_attributeGroup || 
       xsdtype == n_extension || 
       xsdtype == n_restriction || 
689
       (xsdtype == n_simpleType && !inList) || 
Elemer Lelik's avatar
Elemer Lelik committed
690
691
       xsdtype == n_simpleContent ||
       (xsdtype == n_sequence && skipback < 0)
ebensza's avatar
ebensza committed
692
      )) {
Elemer Lelik's avatar
Elemer Lelik committed
693
694
695
696
697
698
699
700
    if (!tagNames.empty() && tagNames.back() == parser->getParentTagName()) {
      if (nillable && tagNames.back() == n_element) {
        parent->modifyValues();
      }
      tagNames.pop_back();
    } else if (tagNames.empty()) {
      parent->actfield = parent;
      parent->lastType = xsdtype;
Elemer Lelik's avatar
Elemer Lelik committed
701
702
    }
  }
703
704
705
  if (xsdtype == n_simpleType) {
    inList = false;
  }
Elemer Lelik's avatar
Elemer Lelik committed
706
707
}

708
709
710
711
712
713
714
715
716
717
718
void ComplexType::modifyList() {
  if (this != actfield) {
    ((SimpleType*)actfield)->modifyList();
    return;
  }
  if (!inList && mode == listMode && parent != NULL) {
    parent->actfield = parent;
    parent->lastType = xsdtype;
  }
}

Elemer Lelik's avatar
Elemer Lelik committed
719
720
721
722
723
void ComplexType::referenceResolving() {
  if (resolved != No) return; // nothing to do
  if(this == subsGroup){
    resolved = Yes;
    return;
Elemer Lelik's avatar
Elemer Lelik committed
724
  }
Elemer Lelik's avatar
Elemer Lelik committed
725
726
727
728
  resolved = InProgress;
  for (List<ComplexType*>::iterator ct = complexfields.begin(); ct; ct = ct->Next) {
    // Referenece resolving of ComplexTypes
    ct->Data->referenceResolving();
Elemer Lelik's avatar
Elemer Lelik committed
729
  }
Elemer Lelik's avatar
Elemer Lelik committed
730
731
732
  for (List<AttributeType*>::iterator attr = attribfields.begin(); attr; attr = attr->Next) {
    //Reference resolving for Attributes
    resolveAttribute(attr->Data);
Elemer Lelik's avatar
Elemer Lelik committed
733
  }
Elemer Lelik's avatar
Elemer Lelik committed
734
735
736
  
  reference_resolving_funtion();
  
Elemer Lelik's avatar
Elemer Lelik committed
737
  if(!substitutionGroup.empty()){
Elemer Lelik's avatar
Elemer Lelik committed
738
    addToSubstitutions();
Elemer Lelik's avatar
Elemer Lelik committed
739
  }
Elemer Lelik's avatar
Elemer Lelik committed
740
  resolved = Yes;
Elemer Lelik's avatar
Elemer Lelik committed
741
742
}

Elemer Lelik's avatar
Elemer Lelik committed
743
744
745
void ComplexType::reference_resolving_funtion() {
  //Every child element references are resolved here.
  if (outside_reference.empty() && basefield == NULL) {
Elemer Lelik's avatar
Elemer Lelik committed
746
747
748
749
750
    //Its not in the resolveElement function because we need the built in type
    //reference too, and then the outside_reference is empty.
    if(xsdtype == n_element){
      collectElementTypes(NULL, NULL);
    }
Elemer Lelik's avatar
Elemer Lelik committed
751
    return;
Elemer Lelik's avatar
Elemer Lelik committed
752
753
  }

Elemer Lelik's avatar
Elemer Lelik committed
754
755
756
757
758
759
760
761
  SimpleType * st = (SimpleType*) TTCN3ModuleInventory::getInstance().lookup(this, want_BOTH);
  if (st == NULL && basefield == NULL) {
    printError(module->getSchemaname(), name.convertedValue,
      "Reference for a non-defined type: " + getReference().repr());
    TTCN3ModuleInventory::getInstance().incrNumErrors();
    outside_reference.set_resolved(NULL);
    return;
  }
Elemer Lelik's avatar
Elemer Lelik committed
762

Elemer Lelik's avatar
Elemer Lelik committed
763
  resolveAttributeGroup(st);
Elemer Lelik's avatar
Elemer Lelik committed
764

Elemer Lelik's avatar
Elemer Lelik committed
765
  resolveGroup(st);
Elemer Lelik's avatar
Elemer Lelik committed
766

Elemer Lelik's avatar
Elemer Lelik committed
767
  resolveElement(st);
Elemer Lelik's avatar
Elemer Lelik committed
768

Elemer Lelik's avatar
Elemer Lelik committed
769
  resolveSimpleTypeExtension();
Elemer Lelik's avatar
Elemer Lelik committed
770

Elemer Lelik's avatar
Elemer Lelik committed
771
  resolveSimpleTypeRestriction();
Elemer Lelik's avatar
Elemer Lelik committed
772

Elemer Lelik's avatar
Elemer Lelik committed
773
  resolveComplexTypeExtension();
Elemer Lelik's avatar
Elemer Lelik committed
774

Elemer Lelik's avatar
Elemer Lelik committed
775
  resolveComplexTypeRestriction();
Elemer Lelik's avatar
Elemer Lelik committed
776

Elemer Lelik's avatar
Elemer Lelik committed
777
  resolveUnion(st);
Elemer Lelik's avatar
Elemer Lelik committed
778

Elemer Lelik's avatar
Elemer Lelik committed
779
780
  addToTypeSubstitutions();

Elemer Lelik's avatar
Elemer Lelik committed
781
782
}

Elemer Lelik's avatar
Elemer Lelik committed
783
784
void ComplexType::setParent(ComplexType * par, SimpleType * child) {
  child->parent = par;
Elemer Lelik's avatar
Elemer Lelik committed
785
786
}

Elemer Lelik's avatar
Elemer Lelik committed
787
788
void ComplexType::applyReference(const SimpleType & other, const bool on_attributes) {
  type.convertedValue = other.getType().convertedValue;
Elemer Lelik's avatar
Elemer Lelik committed
789
  type.originalValueWoPrefix = other.getType().convertedValue.getValueWithoutPrefix(':');
Elemer Lelik's avatar
Elemer Lelik committed
790

791
792
  if (other.getMinOccurs() > getMinOccurs() ||
      other.getMaxOccurs() < getMaxOccurs()) {
Elemer Lelik's avatar
Elemer Lelik committed
793
794
795
796
797
798
    if (!on_attributes) {
      expstring_t temp = memptystr();
      temp = mputprintf(
        temp,
        "The occurrence range (%llu .. %llu) of the element (%s) is not compatible "
        "with the occurrence range (%llu .. %llu) of the referenced element.",
799
800
        getMinOccurs(),
        getMaxOccurs(),
Elemer Lelik's avatar
Elemer Lelik committed
801
802
803
804
805
806
        name.originalValueWoPrefix.c_str(),
        other.getMinOccurs(),
        other.getMaxOccurs());
      printError(module->getSchemaname(), parent->getName().originalValueWoPrefix,
        Mstring(temp));
      Free(temp);
Elemer Lelik's avatar
Elemer Lelik committed
807
808
      TTCN3ModuleInventory::getInstance().incrNumErrors();
    }
Elemer Lelik's avatar
Elemer Lelik committed
809
  } else {
810
811
    setMinOccurs(llmax(getMinOccurs(), other.getMinOccurs()));
    setMaxOccurs(llmin(getMaxOccurs(), other.getMaxOccurs()));
Elemer Lelik's avatar
Elemer Lelik committed
812
813
  }

Elemer Lelik's avatar
Elemer Lelik committed
814
815
816
817
818
  for (List<Mstring>::iterator var = other.getVariantRef().begin(); var; var = var->Next) {
    bool found = false;
    for (List<Mstring>::iterator var1 = variant.begin(); var1; var1 = var1->Next) {
      if (var->Data == var1->Data) {
        found = true;
Elemer Lelik's avatar
Elemer Lelik committed
819
820
821
        break;
      }
    }
Elemer Lelik's avatar
Elemer Lelik committed
822
823
824
    if (!found) {
      variant.push_back(var->Data);
      variant_ref.push_back(var->Data);
Elemer Lelik's avatar
Elemer Lelik committed
825
826
827
    }
  }

Elemer Lelik's avatar
Elemer Lelik committed
828
  builtInBase = other.getBuiltInBase();
829
  
Elemer Lelik's avatar
Elemer Lelik committed
830
831
832
833
834
  length.applyReference(other.getLength());
  pattern.applyReference(other.getPattern());
  enumeration.applyReference(other.getEnumeration());
  whitespace.applyReference(other.getWhitespace());
  value.applyReference(other.getValue());
Elemer Lelik's avatar
Elemer Lelik committed
835
836
}

Elemer Lelik's avatar
Elemer Lelik committed
837
838
839
840
841
842
843
844
845
846
847
848
void ComplexType::nameConversion(NameConversionMode conversion_mode, const List<NamespaceType> & ns) {
  if(!visible) return;
  switch (conversion_mode) {
    case nameMode:
      nameConversion_names(ns);
      break;
    case typeMode:
      nameConversion_types(ns);
      break;
    case fieldMode:
      nameConversion_fields(ns);
      break;
Elemer Lelik's avatar
Elemer Lelik committed
849
850
851
  }
}

Elemer Lelik's avatar
Elemer Lelik committed
852
void ComplexType::nameConversion_names(const List<NamespaceType> &) {
Elemer Lelik's avatar
Elemer Lelik committed
853
854
855
856
  Mstring res, var(module->getTargetNamespace());
  XSDName2TTCN3Name(name.convertedValue, TTCN3ModuleInventory::getInstance().getTypenames(), type_name, res, var);
  name.convertedValue = res;
  bool found = false;
Elemer Lelik's avatar
Elemer Lelik committed
857
  for (List<Mstring>::iterator vari = variant.begin(); vari; vari = vari->Next) {
Elemer Lelik's avatar
Elemer Lelik committed
858
859
860
861
862
863
864
865
    if (vari->Data == "\"untagged\"") {
      found = true;
      break;
    }
  }
  if (!found) {
    addVariant(V_onlyValue, var);
  }
866
  for (List<RootType*>::iterator dep = nameDepList.begin(); dep; dep = dep->Next) {
Elemer Lelik's avatar
Elemer Lelik committed
867
    dep->Data->setTypeValue(res);
Elemer Lelik's avatar
Elemer Lelik committed
868
869
870
  }
}

Elemer Lelik's avatar
Elemer Lelik committed
871
872
873
874
875
876
877
878
879
880
881
882
void ComplexType::nameConversion_types(const List<NamespaceType> & ns) {
  attribfields.sort(compareAttributeNameSpaces);
  attribfields.sort(compareAttributeTypes);
  for (List<AttributeType*>::iterator field = attribfields.begin(); field; field = field->Next) {
    field->Data->nameConversion(typeMode, ns);
  }

  for (List<ComplexType*>::iterator field = complexfields.begin(); field; field = field->Next) {
    field->Data->nameConversion_types(ns);
  }

  Mstring prefix, uri, typeValue;
Elemer Lelik's avatar
Elemer Lelik committed
883
884
885
886

  if (type.convertedValue == "record" ||
    type.convertedValue == "set" ||
    type.convertedValue == "union" ||
Elemer Lelik's avatar
Elemer Lelik committed
887
    type.convertedValue == "enumerated") {
Elemer Lelik's avatar
Elemer Lelik committed
888
    return;
Elemer Lelik's avatar
Elemer Lelik committed
889
  }
Elemer Lelik's avatar
Elemer Lelik committed
890
891

  prefix = type.convertedValue.getPrefix(':');
Elemer Lelik's avatar
Elemer Lelik committed
892
  typeValue = type.convertedValue.getValueWithoutPrefix(':');
Elemer Lelik's avatar
Elemer Lelik committed
893

Elemer Lelik's avatar
Elemer Lelik committed
894
  for (List<NamespaceType>::iterator namesp = ns.begin(); namesp; namesp = namesp->Next) {
Elemer Lelik's avatar
Elemer Lelik committed
895
896
897
898
899
900
    if (prefix == namesp->Data.prefix) {
      uri = namesp->Data.uri;
      break;
    }
  }

Elemer Lelik's avatar
Elemer Lelik committed
901
  QualifiedName in(uri, typeValue); // ns uri + original name
Elemer Lelik's avatar
Elemer Lelik committed
902
903
904

  // Check all known types
  QualifiedNames::iterator origTN = TTCN3ModuleInventory::getInstance().getTypenames().begin();
Elemer Lelik's avatar
Elemer Lelik committed
905
  for (; origTN; origTN = origTN->Next) {
Elemer Lelik's avatar
Elemer Lelik committed
906
907
    if (origTN->Data == in) {
      QualifiedName tmp_name(module->getTargetNamespace(), name.convertedValue);
Elemer Lelik's avatar
Elemer Lelik committed
908
      if (origTN->Data != tmp_name){
Elemer Lelik's avatar
Elemer Lelik committed
909
        break;
Elemer Lelik's avatar
Elemer Lelik committed
910
      }
Elemer Lelik's avatar
Elemer Lelik committed
911
912
913
914
915
    }
  }

  if (origTN != NULL) {
    setTypeValue(origTN->Data.name);
Elemer Lelik's avatar
Elemer Lelik committed
916
  } else {
Elemer Lelik's avatar
Elemer Lelik committed
917
    Mstring res, var;
Elemer Lelik's avatar
Elemer Lelik committed
918
    XSDName2TTCN3Name(typeValue, TTCN3ModuleInventory::getInstance().getTypenames(), type_reference_name, res, var, type.no_replace);
Elemer Lelik's avatar
Elemer Lelik committed
919
920
921
922
    setTypeValue(res);
  }
}

Elemer Lelik's avatar
Elemer Lelik committed
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
void ComplexType::nameConversion_fields(const List<NamespaceType> & ns) {
  QualifiedNames used_field_names;
  
  for (List<AttributeType*>::iterator field = attribfields.begin(); field; field = field->Next) {
    field->Data->nameConversion_names(used_field_names);
  }

  for (List<ComplexType*>::iterator field = complexfields.begin(); field; field = field->Next) {
    if (field->Data->getMinOccurs() == 0 && field->Data->getMaxOccurs() == 0) {
      continue;
    }
    if (!field->Data->isVisible()) {
      continue;
    }
    
    field->Data->nameConversion_fields(ns);
Elemer Lelik's avatar
Elemer Lelik committed
939
940

    Mstring prefix = field->Data->getType().convertedValue.getPrefix(':');
Elemer Lelik's avatar
Elemer Lelik committed
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
    Mstring typeValue = field->Data->getType().convertedValue.getValueWithoutPrefix(':');

    Mstring res, var;
    var = getModule()->getTargetNamespace();
    XSDName2TTCN3Name(typeValue, TTCN3ModuleInventory::getInstance().getTypenames(), type_reference_name, res, var);

    field->Data->addVariant(V_onlyValue, var);
    var = getModule()->getTargetNamespace();

    if (field->Data->getName().list_extension) {
      field->Data->useNameListProperty();
      XSDName2TTCN3Name(field->Data->getName().convertedValue,
        used_field_names, field_name, res, var);
      field->Data->setNameValue(res);
      bool found_in_variant = false;
      for (List<Mstring>::iterator vari = field->Data->getVariant().begin(); vari; vari = vari->Next) {
        if (vari->Data == Mstring("\"untagged\"")) {
          found_in_variant = true;
          break;
        }
      }
      if (!field->Data->getName().originalValueWoPrefix.empty() &&
        field->Data->getName().originalValueWoPrefix != "sequence" &&
        field->Data->getName().originalValueWoPrefix != "choice" &&
        field->Data->getName().originalValueWoPrefix != "elem" &&
        !found_in_variant) {
        field->Data->addVariant(V_nameAs, field->Data->getName().originalValueWoPrefix);
Elemer Lelik's avatar
Elemer Lelik committed
968
969
      }

Elemer Lelik's avatar
Elemer Lelik committed
970
971
972
973
974
975
976
977
978

      if (!found_in_variant) {
        field->Data->addVariant(V_untagged, empty_string, true);
      }
    } else {
      XSDName2TTCN3Name(field->Data->getName().convertedValue,
        used_field_names, field_name, res, var);
      field->Data->setNameValue(res);
      field->Data->addVariant(V_onlyValue, var);
Elemer Lelik's avatar
Elemer Lelik committed
979
    }
Elemer Lelik's avatar
Elemer Lelik committed
980
981
982
983
984
985
986
987

  }
}

void ComplexType::setFieldPaths(Mstring path) {
  if (path.empty()) {
    if (!top) {
      Mstring field_prefix = empty_string;
988
      if(parent->getMinOccurs() == 0 && parent->getMaxOccurs() == ULLONG_MAX){
Elemer Lelik's avatar
Elemer Lelik committed
989
        field_prefix = "[-].";
Elemer Lelik's avatar
Elemer Lelik committed
990
      }
Elemer Lelik's avatar
Elemer Lelik committed
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
      path = field_prefix + getName().convertedValue;
      actualPath = field_prefix + getName().convertedValue;
    }else {
      actualPath = getName().convertedValue;
    }
  } else if (parent != NULL && (parent->getMinOccurs() != 1 || parent->getMaxOccurs() != 1) &&
             (parent->getName().list_extension || parent->mode == listMode)) {
    path = path + Mstring("[-].") + getName().convertedValue;
    actualPath = path;
  } else {
    path = path + Mstring(".") + getName().convertedValue;
    actualPath = path;
  }

  for (List<ComplexType*>::iterator field = complexfields.begin(); field; field = field->Next) {
    field->Data->setFieldPaths(path);
  }
  for (List<AttributeType*>::iterator attr = attribfields.begin(); attr; attr = attr->Next) {
    attr->Data->setFieldPath(path);
  }
}

1013
void ComplexType::subFinalModification() {  
Elemer Lelik's avatar
Elemer Lelik committed
1014
1015
  //Call SimpleType finalModification
  SimpleType::finalModification();
1016
  
Elemer Lelik's avatar
Elemer Lelik committed
1017
  //Set isOptional field
1018
  isOptional = isOptional || (getMinOccurs() == 0 && getMaxOccurs() == 1);
Elemer Lelik's avatar
Elemer Lelik committed
1019
1020
1021
1022
1023
1024
  
  //
  List<Mstring> enumNames;
  for (List<ComplexType*>::iterator field = complexfields.begin(), nextField; field; field = nextField) {
    nextField = field->Next;
    //Remove invisible fields
1025
    if ((field->Data->getMinOccurs() == 0 && field->Data->getMaxOccurs() == 0) || !field->Data->isVisible()) {
Elemer Lelik's avatar
Elemer Lelik committed
1026
1027
1028
1029
1030
      delete field->Data;
      field->Data = NULL;
      complexfields.remove(field);
    } else {
      //Recursive call
1031
      field->Data->subFinalModification();
Elemer Lelik's avatar
Elemer Lelik committed
1032
1033
1034
      //collect <xsd:all> elements
      if (field->Data->fromAll) {
        enumNames.push_back(field->Data->getName().convertedValue);
Elemer Lelik's avatar
Elemer Lelik committed
1035
1036
      }
    }
Elemer Lelik's avatar
Elemer Lelik committed
1037
  }
Elemer Lelik's avatar
Elemer Lelik committed
1038

Elemer Lelik's avatar
Elemer Lelik committed
1039
1040
  ComplexType * embedField = NULL;
  ComplexType * enumField = NULL;
Elemer Lelik's avatar
Elemer Lelik committed
1041

Elemer Lelik's avatar
Elemer Lelik committed
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
  //Find the embed and order fields, and remove them
  for (List<ComplexType*>::iterator field = complexfields.begin(), nextField; field; field = nextField) {
    nextField = field->Next;
    if (field->Data->embed) {
      embedField = new ComplexType(*field->Data);
      embedField->parent = this;
      delete field->Data;
      field->Data = NULL;
      complexfields.remove(field);
    } else if (field->Data->enumerated) {
      enumField = new ComplexType(*field->Data);
      enumField->parent = this;
      delete field->Data;
      field->Data = NULL;
      complexfields.remove(field);
    }
  }
Elemer Lelik's avatar
Elemer Lelik committed
1059

Elemer Lelik's avatar
Elemer Lelik committed
1060
1061
1062
1063
1064
1065
  if (enumField != NULL) {
    //Insert the order field in the front
    complexfields.push_front(enumField);
    //Push the field names into the order field
    for (List<Mstring>::iterator field = enumNames.begin(); field; field = field->Next) {
      enumField->enumfields.push_back(field->Data);
Elemer Lelik's avatar
Elemer Lelik committed
1066
    }
Elemer Lelik's avatar
Elemer Lelik committed
1067
  }
Elemer Lelik's avatar
Elemer Lelik committed
1068

Elemer Lelik's avatar
Elemer Lelik committed
1069
1070
1071
1072
  if (embedField != NULL) {
    //Insert the embed field to the front
    complexfields.push_front(embedField);
  }
Elemer Lelik's avatar
Elemer Lelik committed
1073

Elemer Lelik's avatar
Elemer Lelik committed
1074
1075
1076
1077
1078
1079
1080
  if (with_union) {
    unsigned number = 0;
    for (List<ComplexType*>::iterator field = complexfields.begin(); field; field = field->Next) {
      if (field->Data->name.convertedValue.foundAt("alt_") == field->Data->name.convertedValue.c_str()) {
        if (number == 0) {
          field->Data->name.upload(Mstring("alt_"));
        } else {
1081
1082
1083
          expstring_t new_name = mprintf("alt_%d", number);
          field->Data->name.upload(Mstring(new_name));
          Free(new_name);
Elemer Lelik's avatar
Elemer Lelik committed
1084
        }
Elemer Lelik's avatar
Elemer Lelik committed
1085
        number++;
Elemer Lelik's avatar
Elemer Lelik committed
1086
      }
Elemer Lelik's avatar
Elemer Lelik committed
1087
1088
    }
  }
Elemer Lelik's avatar
Elemer Lelik committed
1089

Elemer Lelik's avatar
Elemer Lelik committed
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
  AttributeType * anyAttr = NULL;
  for (List<AttributeType*>::iterator field = attribfields.begin(), nextField; field; field = nextField) {
    nextField = field->Next;
    field->Data->applyUseAttribute();
    //Find anyattribute, and remove it
    if (field->Data->isAnyAttribute()) {
      anyAttr = new AttributeType(*field->Data);
      setParent(this, anyAttr);
      delete field->Data;
      field->Data = NULL;
      attribfields.remove(field);
    } else {
      field->Data->SimpleType::finalModification();
    }
  }
  
  //Push anyattribute to the front
  if (anyAttr != NULL) {
    anyAttr->applyNamespaceAttribute(V_anyAttributes);
    attribfields.push_back(anyAttr);
  }

  //Substitution group ordering
Elemer Lelik's avatar
Elemer Lelik committed
1113
  if(subsGroup == this || typeSubsGroup == this){ //We are a generated substitution group
Elemer Lelik's avatar
Elemer Lelik committed
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
    //Substitution group never empty
    ComplexType * front = complexfields.front();
    List<ComplexType*>::iterator it = complexfields.begin();
    complexfields.remove(it);
    complexfields.sort(compareComplexTypeNameSpaces);
    complexfields.sort(compareTypes);
    complexfields.push_front(front);
  }
}

void ComplexType::finalModification() {
1125
  subFinalModification();
Elemer Lelik's avatar
Elemer Lelik committed
1126
  setFieldPaths(empty_string);
1127
1128
1129
1130
}

void ComplexType::finalModification2() {
  subFinalModification2();
Elemer Lelik's avatar
Elemer Lelik committed
1131
1132
1133
1134
1135
1136
  List<Mstring> container;
  collectVariants(container);
  variant.clear();
  variant = container;
}

1137
1138
1139
1140
1141
1142
void ComplexType::subFinalModification2() {
  SimpleType::finalModification2();
  for (List<ComplexType*>::iterator field = complexfields.begin(); field; field = field->Next) {
    //Recursive call
    field->Data->subFinalModification2();
  }
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
  for (List<AttributeType*>::iterator field = attribfields.begin(), nextField; field; field = nextField) {
    nextField = field->Next;
    if (field->Data->getUseVal() == prohibited || !field->Data->isVisible()) {
      //Not visible attribute removed
      delete field->Data;
      field->Data = NULL;
      attribfields.remove(field);
    } else {
      field->Data->SimpleType::finalModification2();
    }
1153
1154
1155
  }
}

Elemer Lelik's avatar
Elemer Lelik committed
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
void ComplexType::printToFile(FILE * file) {
  printToFile(file, 0, false);
}

void ComplexType::printToFile(FILE * file, const unsigned level, const bool is_union) {
  if (!isVisible()) {
    return;
  }
  printComment(file, level);
  if (top) {
    fprintf(file, "type ");
    if(mode == listMode){
      printMinOccursMaxOccurs(file, is_union);
      fprintf(file, "%s", type.convertedValue.c_str());
    }else {
      fprintf(file, "%s %s", type.convertedValue.c_str(), name.convertedValue.c_str());
    }
1173
1174
1175
1176
1177
1178
    if(type.convertedValue == "record" || type.convertedValue == "union"){
      fprintf(file, "\n{\n");
      if (attribfields.empty() && complexfields.empty()) {
        fprintf(file, "\n");
      }
    } 
Elemer Lelik's avatar
Elemer Lelik committed
1179
1180
1181
1182
1183
1184
1185
1186
1187

    for (List<ComplexType*>::iterator c = complexfields.begin(), nextField; c; c = nextField) {
      nextField = c->Next;
      if (c->Data->embed || c->Data->enumerated) {
        c->Data->printToFile(file, level + 1, is_union);
        if (c->Next != NULL || !attribfields.empty()) {
          fprintf(file, ",\n");
        } else {
          fprintf(file, "\n");
Elemer Lelik's avatar
Elemer Lelik committed
1188
        }
Elemer Lelik's avatar
Elemer Lelik committed
1189
1190
1191
        delete c->Data;
        c->Data = NULL;
        complexfields.remove(c);
Elemer Lelik's avatar
Elemer Lelik committed
1192
      }
Elemer Lelik's avatar
Elemer Lelik committed
1193
1194
1195
1196
1197
1198
1199
1200
    }

    for (List<AttributeType*>::iterator f = attribfields.begin(); f; f = f->Next) {
      f->Data->printToFile(file, level + 1);
      if (f->Next != NULL || !complexfields.empty()) {
        fprintf(file, ",\n");
      } else {
        fprintf(file, "\n");
Elemer Lelik's avatar
Elemer Lelik committed
1201
1202
      }
    }
Elemer Lelik's avatar
Elemer Lelik committed
1203
1204
1205
1206
1207
1208
1209

    for (List<ComplexType*>::iterator c = complexfields.begin(); c; c = c->Next) {
      c->Data->printToFile(file, level + 1, is_union);
      if (c->Next != NULL) {
        fprintf(file, ",\n");
      } else {
        fprintf(file, "\n");
Elemer Lelik's avatar
Elemer Lelik committed
1210
1211
      }
    }
Elemer Lelik's avatar
Elemer Lelik committed
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
  } else {
    const bool field_is_record = getType().convertedValue == Mstring("record");
    const bool field_is_union = getType().convertedValue == "union";
    if (complexfields.empty() && attribfields.empty() && (field_is_record || field_is_union)) {
      if (field_is_record) {
        indent(file, level);
        printMinOccursMaxOccurs(file, is_union);
        fprintf(file, "%s {\n", getType().convertedValue.c_str());
        indent(file, level);
        fprintf(file, "} %s", getName().convertedValue.c_str());
        if (isOptional) {
          fprintf(file, " optional");
        }
      } else if (field_is_union) {
        indent(file, level);
        printMinOccursMaxOccurs(file, is_union);
        fprintf(file, "%s {\n", getType().convertedValue.c_str());
        indent(file, level + 1);
        fprintf(file, "record length(0 .. 1) of enumerated { NULL_ } choice\n");
        indent(file, level);
        fprintf(file, "} %s", getName().convertedValue.c_str());
        if (isOptional) {
          fprintf(file, " optional");
        }
      }
    } else {
      indent(file, level);
      if (getEnumeration().modified) {
        if (isFloatType(getBuiltInBase())) {
          fprintf(file, "%s (", type.convertedValue.c_str());
          getEnumeration().sortFacets();
          getEnumeration().printToFile(file);
          fprintf(file, ")");
        } else {
          printMinOccursMaxOccurs(file, with_union);
          fprintf(file, "enumerated {\n");
          //getEnumeration().sortFacets();
          getEnumeration().printToFile(file, level);
          fprintf(file, "\n");
          indent(file, level);
          fprintf(file, "} ");
        }
      } else {
        int multiplicity = multi(module, getReference(), this);
        if ((multiplicity > 1) && getReference().get_ref()) {
          fprintf(file, "%s.", getReference().get_ref()->getModule()->getModulename().c_str());
        }
1259
1260
1261
1262
1263
1264
1265
        if (field_is_record || field_is_union || listPrint) {
          unsigned long long int tempMin = getMinOccurs();
          unsigned long long int tempMax = getMaxOccurs();
          if (listPrint) {
            setMinOccurs(listMinOccurs);
            setMaxOccurs(listMaxOccurs);
          }
Elemer Lelik's avatar
Elemer Lelik committed
1266
          printMinOccursMaxOccurs(file, with_union, !first_child || parent->getXsdtype() != n_choice);
1267
1268
1269
          if (listPrint) {
            setMinOccurs(tempMin);
            setMaxOccurs(tempMax);
Elemer Lelik's avatar
Elemer Lelik committed
1270
          }
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
          if (listPrint && complexfields.size() == 0) {
            printMinOccursMaxOccurs(file, false);
            fprintf(file, "%s ",getType().convertedValue.c_str());
          } else {
            fprintf(file, "%s {\n", getType().convertedValue.c_str());
            for (List<AttributeType*>::iterator f = attribfields.begin(); f; f = f->Next) {
              f->Data->printToFile(file, level + 1);
              if (f->Next != NULL || !complexfields.empty()) {
                fprintf(file, ",\n");
              } else {
                fprintf(file, "\n");
              }
            }
Elemer Lelik's avatar
Elemer Lelik committed
1284

1285
1286
1287
1288
1289
1290
1291
            for (List<ComplexType*>::iterator c = complexfields.begin(); c; c = c->Next) {
              c->Data->printToFile(file, level + 1, is_union);
              if (c->Next != NULL) {
                fprintf(file, ",\n");
              } else {
                fprintf(file, "\n");
              }
Elemer Lelik's avatar
Elemer Lelik committed
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
            }
          }
        } else {
          printMinOccursMaxOccurs(file, with_union, !first_child);
          fprintf(file, "%s ", getType().convertedValue.c_str());
          if (getName().convertedValue == Mstring("order") && getType().convertedValue == Mstring("enumerated")) {
            fprintf(file, "{\n");
            for (List<Mstring>::iterator e = enumfields.begin(); e; e = e->Next) {
              indent(file, level + 1);
              fprintf(file, "%s", e->Data.c_str());
              if (e->Next != NULL) {
                fprintf(file, ",\n");
              } else {
                fprintf(file, "\n");
              }
            }
            indent(file, level);
            fprintf(file, "} ");
          }
        }
Elemer Lelik's avatar
Elemer Lelik committed
1312
      }
1313
      if ((field_is_record || field_is_union) && !listPrint) {
Elemer Lelik's avatar
Elemer Lelik committed
1314
1315
        indent(file, level);
        fprintf(file, "} ");
Elemer Lelik's avatar
Elemer Lelik committed
1316
      }
Elemer Lelik's avatar
Elemer Lelik committed
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328

      fprintf(file, "%s", getName().convertedValue.c_str());
      getPattern().printToFile(file);
      getValue().printToFile(file);
      getLength().printToFile(file);
      if (!with_union && isOptional) {
        fprintf(file, " optional");
      }
    }
  }

  if (top) {
1329
1330
1331
    if(type.convertedValue == "record" || type.convertedValue == "union"){
      fprintf(file, "}");
    }
Elemer Lelik's avatar
Elemer Lelik committed
1332
1333
    if(mode == listMode){
      fprintf(file, " %s", name.convertedValue.c_str());
Elemer Lelik's avatar
Elemer Lelik committed
1334
    }
Elemer Lelik's avatar
Elemer Lelik committed
1335
1336
    printVariant(file);
    fprintf(file, ";\n\n\n");
Elemer Lelik's avatar
Elemer Lelik committed
1337
1338
1339