ComplexType.cc 83.4 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() {

168
  if(c != fromElementSubstitution && 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;
188
    case fromElementSubstitution:
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
    if (vari->Data == "\"untagged\"") {
      found = true;
      break;
    }
  }
863
864
  // element or type substitution generated types do not need 'name as' variant
  if (!found && subsGroup != this && typeSubsGroup != this) {
Elemer Lelik's avatar
Elemer Lelik committed
865
866
    addVariant(V_onlyValue, var);
  }
867
  for (List<RootType*>::iterator dep = nameDepList.begin(); dep; dep = dep->Next) {
Elemer Lelik's avatar
Elemer Lelik committed
868
    dep->Data->setTypeValue(res);
Elemer Lelik's avatar
Elemer Lelik committed
869
870
871
  }
}

Elemer Lelik's avatar
Elemer Lelik committed
872
873
874
875
876
877
878
879
880
881
882
883
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
884
885
886
887

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

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

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

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

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

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

Elemer Lelik's avatar
Elemer Lelik committed
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
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
940
941

    Mstring prefix = field->Data->getType().convertedValue.getPrefix(':');
Elemer Lelik's avatar
Elemer Lelik committed
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
968
    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
969
970
      }

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

      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
980
    }
Elemer Lelik's avatar
Elemer Lelik committed
981
982
983
984
985
986
987
988

  }
}

void ComplexType::setFieldPaths(Mstring path) {
  if (path.empty()) {
    if (!top) {
      Mstring field_prefix = empty_string;
989
      if(parent->getMinOccurs() == 0 && parent->getMaxOccurs() == ULLONG_MAX){
Elemer Lelik's avatar
Elemer Lelik committed
990
        field_prefix = "[-].";
Elemer Lelik's avatar
Elemer Lelik committed
991
      }
Elemer Lelik's avatar
Elemer Lelik committed
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
      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);
  }
}

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

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

Elemer Lelik's avatar
Elemer Lelik committed
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
  //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
1060

Elemer Lelik's avatar
Elemer Lelik committed
1061
1062
1063
1064
1065
1066
  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
1067
    }
Elemer Lelik's avatar
Elemer Lelik committed
1068
  }
Elemer Lelik's avatar
Elemer Lelik committed
1069

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

Elemer Lelik's avatar
Elemer Lelik committed
1075
1076
1077
1078
1079
1080
1081
  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 {
1082
1083
1084
          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
1085
        }
Elemer Lelik's avatar
Elemer Lelik committed
1086
        number++;
Elemer Lelik's avatar
Elemer Lelik committed
1087
      }
Elemer Lelik's avatar
Elemer Lelik committed
1088
1089
    }
  }
Elemer Lelik's avatar
Elemer Lelik committed
1090

Elemer Lelik's avatar
Elemer Lelik committed
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
  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
1114
  if(subsGroup == this || typeSubsGroup == this){ //We are a generated substitution group
Elemer Lelik's avatar
Elemer Lelik committed
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
    //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() {
1126
  subFinalModification();
Elemer Lelik's avatar
Elemer Lelik committed
1127
  setFieldPaths(empty_string);
1128
1129
1130
1131
}

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

1138
1139
1140
1141
1142
1143
void ComplexType::subFinalModification2() {
  SimpleType::finalModification2();
  for (List<ComplexType*>::iterator field = complexfields.begin(); field; field = field->Next) {
    //Recursive call
    field->Data->subFinalModification2();
  }
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
  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();
    }
1154
1155
1156
  }
}

Elemer Lelik's avatar
Elemer Lelik committed
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
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());
    }
1174
1175
1176
1177
1178
1179
    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
1180
1181
1182
1183
1184
1185
1186
1187
1188

    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
1189
        }
Elemer Lelik's avatar
Elemer Lelik committed
1190
1191
1192
        delete c->Data;
        c->Data = NULL;
        complexfields.remove(c);
Elemer Lelik's avatar
Elemer Lelik committed
1193
      }
Elemer Lelik's avatar
Elemer Lelik committed
1194
1195
1196
1197
1198
1199
1200
1201
    }

    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
1202
1203
      }
    }
Elemer Lelik's avatar
Elemer Lelik committed
1204
1205
1206
1207
1208
1209
1210

    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
1211
1212
      }
    }
Elemer Lelik's avatar
Elemer Lelik committed
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
1259
  } 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());
        }
1260
1261
1262
1263
1264
1265
1266
        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
1267
          printMinOccursMaxOccurs(file, with_union, !first_child || parent->getXsdtype() != n_choice);
1268
1269
1270
          if (listPrint) {
            setMinOccurs(tempMin);
            setMaxOccurs(tempMax);
Elemer Lelik's avatar
Elemer Lelik committed
1271
          }
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
          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
1285

1286
1287
1288
1289
1290
1291
1292
            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
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
            }
          }
        } 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
1313
      }
1314
      if ((field_is_record || field_is_union) && !listPrint) {
Elemer Lelik's avatar
Elemer Lelik committed
1315
1316
        indent(file, level);
        fprintf(file, "} ");
Elemer Lelik's avatar
Elemer Lelik committed
1317
      }
Elemer Lelik's avatar
Elemer Lelik committed
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329

      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) {
1330
1331
1332
    if(type.convertedValue == "record" || type.convertedValue == "union"){
      fprintf(file, "}");
    }
Elemer Lelik's avatar
Elemer Lelik committed
1333
1334
    if(mode == listMode){
      fprintf(file, " %s", name.convertedValue.c_str());
Elemer Lelik's avatar
Elemer Lelik committed
1335
    }