projects / deliverable / titan.core.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Update README.linux
[deliverable/titan.core.git] / compiler2 / subtype.cc
CommitLineData
970ed795
EL		 1///////////////////////////////////////////////////////////////////////////////
2// Copyright (c) 2000-2014 Ericsson Telecom AB
3// All rights reserved. This program and the accompanying materials
4// are made available under the terms of the Eclipse Public License v1.0
5// which accompanies this distribution, and is available at
6// http://www.eclipse.org/legal/epl-v10.html
7///////////////////////////////////////////////////////////////////////////////
8#include "subtype.hh"
9#include "../common/dbgnew.hh"
10#include "Identifier.hh"
11#include "Value.hh"
12#include "Setting.hh"
13#include "Type.hh"
14#include "CompilerError.hh"
15#include "Valuestuff.hh"
16#include "ttcn3/TtcnTemplate.hh"
17#include "ttcn3/Templatestuff.hh"
18#include "ttcn3/PatternString.hh"
19#include "Constraint.hh"
20
21#include <limits.h>
22
23namespace Common {
24
25/**************************
26class SubTypeParse
27**************************/
28
29SubTypeParse::SubTypeParse(Value *p_single)
30: selection(STP_SINGLE)
31{
32 if (!p_single) FATAL_ERROR("SubTypeParse::SubTypeParse()");
33 single = p_single;
34}
35
36SubTypeParse::SubTypeParse(Value *p_min, bool p_min_exclusive, Value *p_max, bool p_max_exclusive)
37: selection(STP_RANGE)
38{
39 range.min = p_min;
40 range.min_exclusive = p_min_exclusive;
41 range.max = p_max;
42 range.max_exclusive = p_max_exclusive;
43}
44
45SubTypeParse::SubTypeParse(Ttcn::LengthRestriction *p_length)
46: selection(STP_LENGTH)
47{
48 if (!p_length) FATAL_ERROR("SubTypeParse::SubTypeParse()");
49 length = p_length;
50}
51
52SubTypeParse::SubTypeParse(Ttcn::PatternString *p_pattern)
53: selection(STP_PATTERN)
54{
55 if (!p_pattern) FATAL_ERROR("SubTypeParse::SubTypeParse()");
56 pattern = p_pattern;
57}
58
59SubTypeParse::~SubTypeParse()
60{
61 switch (selection) {
62 case STP_SINGLE:
63 delete single;
64 break;
65 case STP_RANGE:
66 delete range.min;
67 delete range.max;
68 break;
69 case STP_LENGTH:
70 delete length;
71 break;
72 case STP_PATTERN:
73 delete pattern;
74 break;
75 default:
76 FATAL_ERROR("SubTypeParse::~SubTypeParse()");
77 }
78}
79
80Value *SubTypeParse::Single() const
81{
82 if (selection != STP_SINGLE) FATAL_ERROR("SubTypeParse::Single()");
83 return single;
84}
85
86Value *SubTypeParse::Min() const
87{
88 if (selection != STP_RANGE) FATAL_ERROR("SubTypeParse::Min()");
89 return range.min;
90}
91
92bool SubTypeParse::MinExclusive() const
93{
94 if (selection != STP_RANGE) FATAL_ERROR("SubTypeParse::MinExclusive()");
95 return range.min_exclusive;
96}
97
98Value *SubTypeParse::Max() const
99{
100 if (selection != STP_RANGE) FATAL_ERROR("SubTypeParse::Max()");
101 return range.max;
102}
103
104bool SubTypeParse::MaxExclusive() const
105{
106 if (selection != STP_RANGE) FATAL_ERROR("SubTypeParse::MaxExclusive()");
107 return range.max_exclusive;
108}
109
110Ttcn::LengthRestriction *SubTypeParse::Length() const
111{
112 if (selection != STP_LENGTH) FATAL_ERROR("SubTypeParse::Length()");
113 return length;
114}
115
116Ttcn::PatternString *SubTypeParse::Pattern() const
117{
118 if (selection != STP_PATTERN) FATAL_ERROR("SubTypeParse::Pattern()");
119 return pattern;
120}
121
122/********************
123class SubtypeConstraint
124********************/
125
126SubtypeConstraint::SubtypeConstraint(subtype_t st)
127{
128 subtype = st;
129 length_restriction = NULL;
130 switch (subtype) {
131 case ST_INTEGER:
132 integer_st = NULL;
133 break;
134 case ST_FLOAT:
135 float_st = NULL;
136 break;
137 case ST_BOOLEAN:
138 boolean_st = NULL;
139 break;
140 case ST_VERDICTTYPE:
141 verdict_st = NULL;
142 break;
143 case ST_BITSTRING:
144 bitstring_st = NULL;
145 break;
146 case ST_HEXSTRING:
147 hexstring_st = NULL;
148 break;
149 case ST_OCTETSTRING:
150 octetstring_st = NULL;
151 break;
152 case ST_CHARSTRING:
153 charstring_st = NULL;
154 break;
155 case ST_UNIVERSAL_CHARSTRING:
156 universal_charstring_st = NULL;
157 break;
158 case ST_OBJID:
159 case ST_RECORD:
160 case ST_SET:
161 case ST_ENUM:
162 case ST_UNION:
163 case ST_FUNCTION:
164 case ST_ALTSTEP:
165 case ST_TESTCASE:
166 value_st = NULL;
167 break;
168 case ST_RECORDOF:
169 case ST_SETOF:
170 recof_st = NULL;
171 break;
172 default:
173 FATAL_ERROR("SubtypeConstraint::SubtypeConstraint()");
174 }
175}
176
177void SubtypeConstraint::copy(const SubtypeConstraint* other)
178{
179 if ((other==NULL) || (other->subtype!=subtype)) FATAL_ERROR("SubtypeConstraint::copy()");
180 switch (subtype) {
181 case ST_INTEGER:
182 delete integer_st;
183 integer_st = other->integer_st ? new IntegerRangeListConstraint(*(other->integer_st)) : NULL;
184 break;
185 case ST_FLOAT:
186 delete float_st;
187 float_st = other->float_st ? new RealRangeListConstraint(*(other->float_st)) : NULL;
188 break;
189 case ST_BOOLEAN:
190 delete boolean_st;
191 boolean_st = other->boolean_st ? new BooleanListConstraint(*(other->boolean_st)) : NULL;
192 break;
193 case ST_VERDICTTYPE:
194 delete verdict_st;
195 verdict_st = other->verdict_st ? new VerdicttypeListConstraint(*(other->verdict_st)) : NULL;
196 break;
197 case ST_BITSTRING:
198 delete bitstring_st;
199 bitstring_st = other->bitstring_st ? new BitstringConstraint(*(other->bitstring_st)) : NULL;
200 break;
201 case ST_HEXSTRING:
202 delete hexstring_st;
203 hexstring_st = other->hexstring_st ? new HexstringConstraint(*(other->hexstring_st)) : NULL;
204 break;
205 case ST_OCTETSTRING:
206 delete octetstring_st;
207 octetstring_st = other->octetstring_st ? new OctetstringConstraint(*(other->octetstring_st)) : NULL;
208 break;
209 case ST_CHARSTRING:
210 delete charstring_st;
211 charstring_st = other->charstring_st ? new CharstringSubtypeTreeElement(*(other->charstring_st)) : NULL;
212 break;
213 case ST_UNIVERSAL_CHARSTRING:
214 delete universal_charstring_st;
215 universal_charstring_st = other->universal_charstring_st ? new UniversalCharstringSubtypeTreeElement(*(other->universal_charstring_st)) : NULL;
216 break;
217 case ST_OBJID:
218 case ST_RECORD:
219 case ST_SET:
220 case ST_ENUM:
221 case ST_UNION:
222 case ST_FUNCTION:
223 case ST_ALTSTEP:
224 case ST_TESTCASE:
225 delete value_st;
226 value_st = other->value_st ? new ValueListConstraint(*(other->value_st)) : NULL;
227 break;
228 case ST_RECORDOF:
229 case ST_SETOF:
230 delete recof_st;
231 recof_st = other->recof_st ? new RecofConstraint(*(other->recof_st)) : NULL;
232 break;
233 default:
234 FATAL_ERROR("SubtypeConstraint::copy()");
235 }
236 delete length_restriction;
237 length_restriction = other->length_restriction ? new SizeRangeListConstraint(*(other->length_restriction)) : NULL;
238}
239
240// used by get_asn_type_constraint() to store singleton objects and delete them on program exit
241struct AsnTypeConstraintSingleton
242{
243 SubtypeConstraint *printablestring_stc, *numericstring_stc, *bmpstring_stc;
244 AsnTypeConstraintSingleton():
245 printablestring_stc(NULL), numericstring_stc(NULL), bmpstring_stc(NULL) {}
246 ~AsnTypeConstraintSingleton();
247};
248
249AsnTypeConstraintSingleton::~AsnTypeConstraintSingleton()
250{
251 delete printablestring_stc;
252 delete numericstring_stc;
253 delete bmpstring_stc;
254}
255
256SubtypeConstraint* SubtypeConstraint::get_asn_type_constraint(Type* type)
257{
258 static AsnTypeConstraintSingleton asn_tcs;
259 static const char_limit_t zero('0'), nine('9'),
260 bigA('A'), bigZ('Z'), smalla('a'), smallz('z');
261 static const universal_char_limit_t uni_zero(0);
262 static const universal_char_limit_t uni_ffff((1<<16)-1);
263 static const CharRangeListConstraint numeric_string_char_range(
264 CharRangeListConstraint(zero, nine) +
265 CharRangeListConstraint(char_limit_t(' ')));
266 static const CharRangeListConstraint printable_string_char_range(
267 CharRangeListConstraint(bigA, bigZ) +
268 CharRangeListConstraint(smalla, smallz) +
269 CharRangeListConstraint(zero , nine) +
270 CharRangeListConstraint(char_limit_t(' ')) +
271 CharRangeListConstraint(char_limit_t('\'')) +
272 CharRangeListConstraint(char_limit_t('(')) +
273 CharRangeListConstraint(char_limit_t(')')) +
274 CharRangeListConstraint(char_limit_t('+')) +
275 CharRangeListConstraint(char_limit_t(',')) +
276 CharRangeListConstraint(char_limit_t('-')) +
277 CharRangeListConstraint(char_limit_t('.')) +
278 CharRangeListConstraint(char_limit_t('/')) +
279 CharRangeListConstraint(char_limit_t(':')) +
280 CharRangeListConstraint(char_limit_t('=')) +
281 CharRangeListConstraint(char_limit_t('?')));
282 static const UniversalCharRangeListConstraint bmp_string_char_range(
283 UniversalCharRangeListConstraint(uni_zero, uni_ffff));
284
285 switch (type->get_typetype()) {
286 case Type::T_TELETEXSTRING:
287 // TODO: based on ITU-T Recommendation T.61
288 return NULL;
289 case Type::T_VIDEOTEXSTRING:
290 // TODO: based on ITU-T Recommendation T.100 and T.101
291 return NULL;
292 case Type::T_NUMERICSTRING:
293 if (asn_tcs.numericstring_stc==NULL) {
294 asn_tcs.numericstring_stc = new SubtypeConstraint(ST_CHARSTRING);
295 asn_tcs.numericstring_stc->charstring_st = new CharstringSubtypeTreeElement(numeric_string_char_range, false);
296 }
297 return asn_tcs.numericstring_stc;
298 case Type::T_PRINTABLESTRING:
299 if (asn_tcs.printablestring_stc==NULL) {
300 asn_tcs.printablestring_stc = new SubtypeConstraint(ST_CHARSTRING);
301 asn_tcs.printablestring_stc->charstring_st = new CharstringSubtypeTreeElement(printable_string_char_range, false);
302 }
303 return asn_tcs.printablestring_stc;
304 case Type::T_BMPSTRING:
305 if (asn_tcs.bmpstring_stc==NULL) {
306 asn_tcs.bmpstring_stc = new SubtypeConstraint(ST_UNIVERSAL_CHARSTRING);
307 asn_tcs.bmpstring_stc->universal_charstring_st = new UniversalCharstringSubtypeTreeElement(bmp_string_char_range, false);
308 }
309 return asn_tcs.bmpstring_stc;
310 default:
311 return NULL;
312 }
313}
314
315SubtypeConstraint* SubtypeConstraint::create_from_asn_value(Type* type, Value* value)
316{
317 Value* v = value->get_value_refd_last();
318 subtype_t st_t = type->get_subtype_type();
319 if ( (st_t==ST_ERROR) || (v->get_valuetype()==Value::V_ERROR) ) return NULL;
320 SubtypeConstraint* stc = new SubtypeConstraint(st_t);
321 switch (v->get_valuetype()) {
322 case Value::V_INT:
323 if (st_t!=ST_INTEGER) FATAL_ERROR("SubtypeConstraint::create_from_asn_value()");
324 stc->integer_st = new IntegerRangeListConstraint(int_limit_t(*(v->get_val_Int())));
325 break;
326 case Value::V_REAL: {
327 if (st_t!=ST_FLOAT) FATAL_ERROR("SubtypeConstraint::create_from_asn_value()");
328 ttcn3float r = v->get_val_Real();
329 if (r!=r) stc->float_st = new RealRangeListConstraint(true);
330 else stc->float_st = new RealRangeListConstraint(real_limit_t(r));
331 } break;
332 case Value::V_BOOL:
333 if (st_t!=ST_BOOLEAN) FATAL_ERROR("SubtypeConstraint::create_from_asn_value()");
334 stc->boolean_st = new BooleanListConstraint(v->get_val_bool());
335 break;
336 case Value::V_OID:
337 case Value::V_ROID:
338 if (v->has_oid_error()) goto invalid_value;
339 if (st_t!=ST_OBJID) FATAL_ERROR("SubtypeConstraint::create_from_asn_value()");
340 stc->value_st = new ValueListConstraint(v);
341 break;
342 case Value::V_BSTR:
343 if (st_t!=ST_BITSTRING) FATAL_ERROR("SubtypeConstraint::create_from_asn_value()");
344 stc->bitstring_st = new BitstringConstraint(v->get_val_str());
345 break;
346 case Value::V_HSTR:
347 if (st_t!=ST_HEXSTRING) FATAL_ERROR("SubtypeConstraint::create_from_asn_value()");
348 stc->hexstring_st = new HexstringConstraint(v->get_val_str());
349 break;
350 case Value::V_OSTR:
351 if (st_t!=ST_OCTETSTRING) FATAL_ERROR("SubtypeConstraint::create_from_asn_value()");
352 stc->octetstring_st = new OctetstringConstraint(v->get_val_str());
353 break;
354 case Value::V_CSTR:
355 if (st_t!=ST_CHARSTRING) FATAL_ERROR("SubtypeConstraint::create_from_asn_value()");
356 stc->charstring_st = new CharstringSubtypeTreeElement(StringValueConstraint<string>(v->get_val_str()));
357 break;
358 case Value::V_ISO2022STR:
359 if (st_t!=ST_CHARSTRING) FATAL_ERROR("SubtypeConstraint::create_from_asn_value()");
360 stc->charstring_st = new CharstringSubtypeTreeElement(StringValueConstraint<string>(v->get_val_iso2022str()));
361 break;
362 case Value::V_CHARSYMS:
363 case Value::V_USTR:
364 if (st_t!=ST_UNIVERSAL_CHARSTRING) FATAL_ERROR("SubtypeConstraint::create_from_asn_value()");
365 stc->universal_charstring_st = new UniversalCharstringSubtypeTreeElement(StringValueConstraint<ustring>(v->get_val_ustr()));
366 break;
367 case Value::V_ENUM:
368 case Value::V_NULL: // FIXME: should go to ST_NULL
369 if (st_t!=ST_ENUM) FATAL_ERROR("SubtypeConstraint::create_from_asn_value()");
370 stc->value_st = new ValueListConstraint(v);
371 break;
372 case Value::V_CHOICE:
373 case Value::V_OPENTYPE: // FIXME?
374 if (st_t!=ST_UNION) FATAL_ERROR("SubtypeConstraint::create_from_asn_value()");
375 stc->value_st = new ValueListConstraint(v);
376 break;
377 case Value::V_SEQ:
378 if (st_t!=ST_RECORD) FATAL_ERROR("SubtypeConstraint::create_from_asn_value()");
379 stc->value_st = new ValueListConstraint(v);
380 break;
381 case Value::V_SET:
382 if (st_t!=ST_SET) FATAL_ERROR("SubtypeConstraint::create_from_asn_value()");
383 stc->value_st = new ValueListConstraint(v);
384 break;
385 case Value::V_SEQOF:
386 if (st_t!=ST_RECORDOF) FATAL_ERROR("SubtypeConstraint::create_from_asn_value()");
387 stc->recof_st = new RecofConstraint(v);
388 break;
389 case Value::V_SETOF:
390 if (st_t!=ST_SETOF) FATAL_ERROR("SubtypeConstraint::create_from_asn_value()");
391 stc->recof_st = new RecofConstraint(v);
392 break;
393 default:
394 goto invalid_value;
395 }
396 return stc;
397invalid_value:
398 delete stc;
399 return NULL;
400}
401
402SubtypeConstraint* SubtypeConstraint::create_from_asn_charvalues(Type* type, Value* value)
403{
404 Value* v = value->get_value_refd_last();
405 subtype_t st_t = type->get_subtype_type();
406 if ( (st_t==ST_ERROR) || (v->get_valuetype()==Value::V_ERROR) ) return NULL;
407 SubtypeConstraint* stc = new SubtypeConstraint(st_t);
408 switch (v->get_valuetype()) {
409 case Value::V_CSTR:
410 case Value::V_ISO2022STR: {
411 if (st_t!=ST_CHARSTRING) FATAL_ERROR("SubtypeConstraint::create_from_asn_charvalues()");
412 CharRangeListConstraint charvalues;
413 string val_str = (v->get_valuetype()==Value::V_CSTR) ? v->get_val_str() : v->get_val_iso2022str();
414 for (size_t i=0; i<val_str.size(); i++) {
415 if (!char_limit_t::is_valid_value(val_str[i])) {
416 value->error("Invalid char in string %s at index %lu",
417 value->get_stringRepr().c_str(), (unsigned long)i);
418 goto invalid_value;
419 }
420 charvalues = charvalues + CharRangeListConstraint(val_str[i]);
421 }
422 stc->charstring_st = new CharstringSubtypeTreeElement(charvalues, true);
423 } break;
424 case Value::V_CHARSYMS: {
425 case Value::V_USTR:
426 if (st_t!=ST_UNIVERSAL_CHARSTRING) FATAL_ERROR("SubtypeConstraint::create_from_asn_charvalues()");
427 UniversalCharRangeListConstraint ucharvalues;
428 ustring val_ustr = v->get_val_ustr();
429 for (size_t i=0; i<val_ustr.size(); i++) {
430 if (!universal_char_limit_t::is_valid_value(val_ustr[i])) {
431 value->error("Invalid universal char in string %s at index %lu",
432 value->get_stringRepr().c_str(), (unsigned long)i);
433 goto invalid_value;
434 }
435 ucharvalues = ucharvalues + UniversalCharRangeListConstraint(val_ustr[i]);
436 }
437 stc->universal_charstring_st = new UniversalCharstringSubtypeTreeElement(ucharvalues, true);
438 } break;
439 default:
440 // error was already reported
441 goto invalid_value;
442 }
443 return stc;
444invalid_value:
445 delete stc;
446 return NULL;
447}
448
449int_limit_t SubtypeConstraint::get_int_limit(bool is_upper, Location* loc)
450{
451 int_limit_t default_limit = is_upper ?
452 int_limit_t::maximum :
453 ((subtype==ST_INTEGER) ? int_limit_t::minimum : int_limit_t(int_val_t((Int)0)));
454 switch (subtype) {
455 case ST_INTEGER:
456 if (integer_st) {
457 if (integer_st->is_empty()==TTRUE) {
458 loc->error("Cannot determine the value of %s: the parent subtype is an empty set.",
459 is_upper?"MAX":"MIN");
460 return default_limit;
461 } else {
462 return is_upper ? integer_st->get_maximal() : integer_st->get_minimal();
463 }
464 }
465 return default_limit;
466 case ST_BITSTRING:
467 if (bitstring_st) {
468 size_limit_t sl;
469 tribool tb = bitstring_st->get_size_limit(is_upper, sl);
470 if (tb==TTRUE) return sl.to_int_limit();
471 break;
472 }
473 return default_limit;
474 case ST_HEXSTRING:
475 if (hexstring_st) {
476 size_limit_t sl;
477 tribool tb = hexstring_st->get_size_limit(is_upper, sl);
478 if (tb==TTRUE) return sl.to_int_limit();
479 break;
480 }
481 return default_limit;
482 case ST_OCTETSTRING:
483 if (octetstring_st) {
484 size_limit_t sl;
485 tribool tb = octetstring_st->get_size_limit(is_upper, sl);
486 if (tb==TTRUE) return sl.to_int_limit();
487 break;
488 }
489 return default_limit;
490 case ST_CHARSTRING:
491 if (charstring_st) {
492 size_limit_t sl;
493 tribool tb = charstring_st->get_size_limit(is_upper, sl);
494 switch (tb) {
495 case TFALSE:
496 loc->error("Cannot determine the value of %s: the parent subtype does "
497 "not define a %simal size value", is_upper?"MAX":"MIN", is_upper?"max":"min");
498 break;
499 case TUNKNOWN:
500 loc->warning("Cannot determine the value of %s from parent subtype %s",
501 is_upper?"MAX":"MIN", to_string().c_str());
502 break;
503 case TTRUE:
504 return sl.to_int_limit();
505 default:
506 FATAL_ERROR("SubtypeConstraint::get_int_limit()");
507 }
508 }
509 return default_limit;
510 case ST_UNIVERSAL_CHARSTRING:
511 if (universal_charstring_st) {
512 size_limit_t sl;
513 tribool tb = universal_charstring_st->get_size_limit(is_upper, sl);
514 switch (tb) {
515 case TFALSE:
516 loc->error("Cannot determine the value of %s: the parent subtype does "
517 "not define a %simal size value", is_upper?"MAX":"MIN", is_upper?"max":"min");
518 break;
519 case TUNKNOWN:
520 loc->warning("Cannot determine the value of %s from parent subtype %s",
521 is_upper?"MAX":"MIN", to_string().c_str());
522 break;
523 case TTRUE:
524 return sl.to_int_limit();
525 default:
526 FATAL_ERROR("SubtypeConstraint::get_int_limit()");
527 }
528 }
529 return default_limit;
530 case ST_RECORDOF:
531 case ST_SETOF:
532 if (recof_st) {
533 size_limit_t sl;
534 tribool tb = recof_st->get_size_limit(is_upper, sl);
535 if (tb==TTRUE) return sl.to_int_limit();
536 break;
537 }
538 return default_limit;
539 default:
540 FATAL_ERROR("SubtypeConstraint::get_int_limit()");
541 }
542 loc->error("Cannot determine the value of %s from parent subtype %s",
543 is_upper?"MAX":"MIN", to_string().c_str());
544 return default_limit;
545}
546
547SubtypeConstraint* SubtypeConstraint::create_from_asn_range(
548 Value* vmin, bool min_exclusive, Value* vmax, bool max_exclusive,
549 Location* loc, subtype_t st_t, SubtypeConstraint* parent_subtype)
550{
551 switch (st_t) {
552 case SubtypeConstraint::ST_INTEGER: {
553 if (((vmin!=NULL) && (vmin->get_valuetype()!=Value::V_INT)) ||
554 ((vmax!=NULL) && (vmax->get_valuetype()!=Value::V_INT))) return NULL;
555
556 int_limit_t min_limit;
557 if (vmin) {
558 min_limit = int_limit_t(*(vmin->get_val_Int()));
559 } else { // MIN was used
560 if (parent_subtype) {
561 min_limit = parent_subtype->get_int_limit(false, loc);
562 } else {
563 min_limit = int_limit_t::minimum;
564 }
565 }
566
567 if (min_exclusive) {
568 if (min_limit==int_limit_t::minimum) {
569 loc->error("invalid lower boundary, -infinity cannot be excluded from an INTEGER value range constraint");
570 return NULL;
571 } else {
572 min_limit = min_limit.next();
573 }
574 }
575
576 int_limit_t max_limit;
577 if (vmax) {
578 max_limit = int_limit_t(*(vmax->get_val_Int()));
579 } else { // MAX was used
580 if (parent_subtype) {
581 max_limit = parent_subtype->get_int_limit(true, loc);
582 } else {
583 max_limit = int_limit_t::maximum;
584 }
585 }
586
587 if (max_exclusive) {
588 if (max_limit==int_limit_t::maximum) {
589 loc->error("invalid upper boundary, infinity cannot be excluded from an INTEGER value range constraint");
590 return NULL;
591 } else {
592 max_limit = max_limit.previous();
593 }
594 }
595 if (max_limit<min_limit) {
596 loc->error("lower boundary is bigger than upper boundary in INTEGER value range constraint");
597 return NULL;
598 }
599 SubtypeConstraint* stc = new SubtypeConstraint(st_t);
600 stc->integer_st = new IntegerRangeListConstraint(min_limit, max_limit);
601 return stc;
602 } break;
603 case ST_FLOAT: {
604 if (((vmin!=NULL) && (vmin->get_valuetype()!=Value::V_REAL)) ||
605 ((vmax!=NULL) && (vmax->get_valuetype()!=Value::V_REAL))) return NULL;
606 if ((vmin!=NULL) && (vmin->get_val_Real()!=vmin->get_val_Real())) {
607 loc->error("lower boundary cannot be NOT-A-NUMBER in REAL value range constraint");
608 return NULL;
609 }
610 if ((vmax!=NULL) && (vmax->get_val_Real()!=vmax->get_val_Real())) {
611 loc->error("upper boundary cannot be NOT-A-NUMBER in REAL value range constraint");
612 return NULL;
613 }
614
615 if (parent_subtype && (parent_subtype->subtype!=ST_FLOAT)) FATAL_ERROR("SubtypeConstraint::create_from_asn_range()");
616 real_limit_t min_limit;
617 if (vmin) {
618 min_limit = real_limit_t(vmin->get_val_Real());
619 } else { // MIN was used
620 if (parent_subtype && parent_subtype->float_st) {
621 if (parent_subtype->float_st->is_range_empty()==TTRUE) {
622 loc->error("Cannot determine the value of MIN: the parent subtype has no range");
623 min_limit = real_limit_t::minimum;
624 } else {
625 min_limit = parent_subtype->float_st->get_minimal();
626 }
627 } else {
628 min_limit = real_limit_t::minimum;
629 }
630 }
631
632 if (min_exclusive) {
633 min_limit = min_limit.next();
634 }
635
636 real_limit_t max_limit;
637 if (vmax) {
638 max_limit = real_limit_t(vmax->get_val_Real());
639 } else { // MAX was used
640 if (parent_subtype && parent_subtype->float_st) {
641 if (parent_subtype->float_st->is_range_empty()==TTRUE) {
642 loc->error("Cannot determine the value of MAX: the parent subtype has no range");
643 max_limit = real_limit_t::maximum;
644 } else {
645 max_limit = parent_subtype->float_st->get_maximal();
646 }
647 } else {
648 max_limit = real_limit_t::maximum;
649 }
650 }
651
652 if (max_exclusive) {
653 max_limit = max_limit.previous();
654 }
655 if (max_limit<min_limit) {
656 loc->error("lower boundary is bigger than upper boundary in REAL value range constraint");
657 return NULL;
658 }
659 SubtypeConstraint* stc = new SubtypeConstraint(st_t);
660 stc->float_st = new RealRangeListConstraint(min_limit, max_limit);
661 return stc;
662 } break;
663 case ST_CHARSTRING: {
664 if (((vmin!=NULL) && (vmin->get_valuetype()!=Value::V_CSTR)) ||
665 ((vmax!=NULL) && (vmax->get_valuetype()!=Value::V_CSTR))) return NULL;
666 if (vmin && (vmin->get_val_str().size()!=1)) {
667 vmin->error("lower boundary of string value range constraint must be a single element string");
668 return NULL;
669 }
670 if (vmax && (vmax->get_val_str().size()!=1)) {
671 vmax->error("upper boundary of string value range constraint must be a single element string");
672 return NULL;
673 }
674 if (vmin && !char_limit_t::is_valid_value(*vmin->get_val_str().c_str())) {
675 vmin->error("lower boundary of string value range constraint is an invalid char");
676 return NULL;
677 }
678 if (vmax && !char_limit_t::is_valid_value(*vmax->get_val_str().c_str())) {
679 vmax->error("upper boundary of string value range constraint is an invalid char");
680 return NULL;
681 }
682
683 if (parent_subtype && (parent_subtype->subtype!=ST_CHARSTRING)) FATAL_ERROR("SubtypeConstraint::create_from_asn_range()");
684
685 char_limit_t min_limit;
686 if (vmin) {
687 min_limit = char_limit_t(*vmin->get_val_str().c_str());
688 } else { // MIN was used
689 if (parent_subtype && parent_subtype->charstring_st) {
690 tribool tb = parent_subtype->charstring_st->get_alphabet_limit(false, min_limit);
691 switch (tb) {
692 case TFALSE:
693 loc->error("Cannot determine the value of MIN: the parent subtype does not define a minimal char value");
694 min_limit = char_limit_t::minimum;
695 break;
696 case TUNKNOWN:
697 loc->warning("Cannot determine the value of MIN, using the minimal char value of the type");
698 min_limit = char_limit_t::minimum;
699 break;
700 case TTRUE:
701 // min_limit was set to the correct value
702 break;
703 default:
704 FATAL_ERROR("SubtypeConstraint::create_from_asn_range()");
705 }
706 } else {
707 min_limit = char_limit_t::minimum;
708 }
709 }
710
711 if (min_exclusive) {
712 if (min_limit==char_limit_t::maximum) {
713 loc->error("exclusive lower boundary is not a legal character");
714 return NULL;
715 }
716 min_limit = min_limit.next();
717 }
718
719 char_limit_t max_limit;
720 if (vmax) {
721 max_limit = char_limit_t(*vmax->get_val_str().c_str());
722 } else { // MAX was used
723 if (parent_subtype && parent_subtype->charstring_st) {
724 tribool tb = parent_subtype->charstring_st->get_alphabet_limit(true, max_limit);
725 switch (tb) {
726 case TFALSE:
727 loc->error("Cannot determine the value of MAX: the parent subtype does not define a maximal char value");
728 max_limit = char_limit_t::maximum;
729 break;
730 case TUNKNOWN:
731 loc->warning("Cannot determine the value of MAX, using the maximal char value of the type");
732 max_limit = char_limit_t::maximum;
733 break;
734 case TTRUE:
735 // max_limit was set to the correct value
736 break;
737 default:
738 FATAL_ERROR("SubtypeConstraint::create_from_asn_range()");
739 }
740 } else {
741 max_limit = char_limit_t::maximum;
742 }
743 }
744
745 if (max_exclusive) {
746 if (max_limit==char_limit_t::minimum) {
747 loc->error("exclusive upper boundary is not a legal character");
748 return NULL;
749 }
750 max_limit = max_limit.previous();
751 }
752 if (max_limit<min_limit) {
753 loc->error("lower boundary is bigger than upper boundary in string value range constraint");
754 return NULL;
755 }
756 SubtypeConstraint* stc = new SubtypeConstraint(st_t);
757 stc->charstring_st = new CharstringSubtypeTreeElement(CharRangeListConstraint(min_limit,max_limit), true);
758 return stc;
759 } break;
760 case ST_UNIVERSAL_CHARSTRING: {
761 if (((vmin!=NULL) && (vmin->get_valuetype()!=Value::V_USTR)) ||
762 ((vmax!=NULL) && (vmax->get_valuetype()!=Value::V_USTR))) return NULL;
763 if (vmin && (vmin->get_val_ustr().size()!=1)) {
764 vmin->error("lower boundary of string value range constraint must be a single element string");
765 return NULL;
766 }
767 if (vmax && (vmax->get_val_ustr().size()!=1)) {
768 vmax->error("upper boundary of string value range constraint must be a single element string");
769 return NULL;
770 }
771 if (vmin && !universal_char_limit_t::is_valid_value(*vmin->get_val_ustr().u_str())) {
772 vmin->error("lower boundary of string value range constraint is an invalid universal char");
773 return NULL;
774 }
775 if (vmax && !universal_char_limit_t::is_valid_value(*vmax->get_val_ustr().u_str())) {
776 vmax->error("upper boundary of string value range constraint is an invalid universal char");
777 return NULL;
778 }
779
780 if (parent_subtype && (parent_subtype->subtype!=ST_UNIVERSAL_CHARSTRING)) FATAL_ERROR("SubtypeConstraint::create_from_asn_range()");
781 universal_char_limit_t min_limit;
782 if (vmin) {
783 min_limit = universal_char_limit_t(*vmin->get_val_ustr().u_str());
784 } else { // MIN was used
785 if (parent_subtype && parent_subtype->universal_charstring_st) {
786 tribool tb = parent_subtype->universal_charstring_st->get_alphabet_limit(false, min_limit);
787 switch (tb) {
788 case TFALSE:
789 loc->error("Cannot determine the value of MIN: the parent subtype does not define a minimal char value");
790 min_limit = universal_char_limit_t::minimum;
791 break;
792 case TUNKNOWN:
793 loc->warning("Cannot determine the value of MIN, using the minimal char value of the type");
794 min_limit = universal_char_limit_t::minimum;
795 break;
796 case TTRUE:
797 // min_limit was set to the correct value
798 break;
799 default:
800 FATAL_ERROR("SubtypeConstraint::create_from_asn_range()");
801 }
802 } else {
803 min_limit = universal_char_limit_t::minimum;
804 }
805 }
806
807 if (min_exclusive) {
808 if (min_limit==universal_char_limit_t::maximum) {
809 loc->error("exclusive lower boundary is not a legal character");
810 return NULL;
811 }
812 min_limit = min_limit.next();
813 }
814
815 universal_char_limit_t max_limit;
816 if (vmax) {
817 max_limit = universal_char_limit_t(*vmax->get_val_ustr().u_str());
818 } else { // MAX was used
819 if (parent_subtype && parent_subtype->universal_charstring_st) {
820 tribool tb = parent_subtype->universal_charstring_st->get_alphabet_limit(true, max_limit);
821 switch (tb) {
822 case TFALSE:
823 loc->error("Cannot determine the value of MAX: the parent subtype does not define a maximal char value");
824 max_limit = universal_char_limit_t::maximum;
825 break;
826 case TUNKNOWN:
827 loc->warning("Cannot determine the value of MAX, using the maximal char value of the type");
828 max_limit = universal_char_limit_t::maximum;
829 break;
830 case TTRUE:
831 // max_limit was set to the correct value
832 break;
833 default:
834 FATAL_ERROR("SubtypeConstraint::create_from_asn_range()");
835 }
836 } else {
837 max_limit = universal_char_limit_t::maximum;
838 }
839 }
840
841 if (max_exclusive) {
842 if (max_limit==universal_char_limit_t::minimum) {
843 loc->error("exclusive upper boundary is not a legal character");
844 return NULL;
845 }
846 max_limit = max_limit.previous();
847 }
848 if (max_limit<min_limit) {
849 loc->error("lower boundary is bigger than upper boundary in string value range constraint");
850 return NULL;
851 }
852 SubtypeConstraint* stc = new SubtypeConstraint(st_t);
853 stc->universal_charstring_st = new UniversalCharstringSubtypeTreeElement(UniversalCharRangeListConstraint(min_limit,max_limit), true);
854 return stc;
855 } break;
856 default:
857 FATAL_ERROR("SubtypeConstraint::create_from_asn_range()");
858 }
859 return NULL;
860}
861
862SubtypeConstraint* SubtypeConstraint::create_from_contained_subtype(SubtypeConstraint* contained_stc, bool char_context, Location* loc)
863{
864 if (contained_stc==NULL) return NULL;
865 SubtypeConstraint* rv_stc = NULL;
866 if (char_context) {
867 switch (contained_stc->get_subtypetype()) {
868 case ST_CHARSTRING:
869 if (contained_stc->charstring_st==NULL) {
870 rv_stc = new SubtypeConstraint(contained_stc->get_subtypetype()); // full set
871 } else {
872 if (contained_stc->charstring_st->is_valid_range()) {
873 rv_stc = new SubtypeConstraint(contained_stc->get_subtypetype());
874 rv_stc->copy(contained_stc);
875 rv_stc->charstring_st->set_char_context(true);
876 } else {
877 loc->error("The type of the contained subtype constraint cannot be used in a permitted alphabet constraint");
878 }
879 }
880 break;
881 case ST_UNIVERSAL_CHARSTRING:
882 if (contained_stc->universal_charstring_st==NULL) {
883 rv_stc = new SubtypeConstraint(contained_stc->get_subtypetype()); // full set
884 } else {
885 if (contained_stc->universal_charstring_st->is_valid_range()) {
886 rv_stc = new SubtypeConstraint(contained_stc->get_subtypetype());
887 rv_stc->copy(contained_stc);
888 rv_stc->universal_charstring_st->set_char_context(true);
889 } else {
890 loc->error("The type of the contained subtype constraint cannot be used in a permitted alphabet constraint");
891 }
892 }
893 break;
894 default:
895 // error was already reported
896 break;
897 }
898 } else {
899 rv_stc = new SubtypeConstraint(contained_stc->get_subtypetype());
900 rv_stc->copy(contained_stc);
901 }
902 return rv_stc;
903}
904
905SubtypeConstraint* SubtypeConstraint::create_asn_size_constraint(
906 SubtypeConstraint* integer_stc, bool char_context, Type* type, Location* loc)
907{
908 if (integer_stc==NULL) return NULL;
909 // convert IntegerRangeListConstraint to SizeRangeListConstraint
910 if (integer_stc->subtype!=ST_INTEGER) FATAL_ERROR("SubtypeConstraint::create_asn_size_constraint()");
911 SizeRangeListConstraint size_constraint(size_limit_t::minimum, size_limit_t::maximum);
912 if (integer_stc->integer_st) {
913 static const int_val_t zero((Int)0);
914 static const int_limit_t ilt0(zero);
915 IntegerRangeListConstraint valid_range(ilt0, int_limit_t::maximum);
916 if (integer_stc->integer_st->is_subset(valid_range)==TFALSE) {
917 loc->error("Range %s is not a valid range for a size constraint", integer_stc->to_string().c_str());
918 } else {
919 bool success = convert_int_to_size(*(integer_stc->integer_st), size_constraint);
920 if (!success) {
921 loc->error("One or more INTEGER values of range %s are too large to be used in a size constraint", integer_stc->to_string().c_str());
922 }
923 }
924 }
925 subtype_t st_t = type->get_subtype_type();
926 if (st_t==ST_ERROR) return NULL;
927 SubtypeConstraint* stc = new SubtypeConstraint(st_t);
928
929 if (!char_context) {
930 stc->length_restriction = new SizeRangeListConstraint(size_constraint); // FIXME? : is this Ok if not a top level constraint?
931 }
932
933 switch (st_t) {
934 case ST_BITSTRING:
935 stc->bitstring_st = new BitstringConstraint(size_constraint);
936 break;
937 case ST_HEXSTRING:
938 stc->hexstring_st = new HexstringConstraint(size_constraint);
939 break;
940 case ST_OCTETSTRING:
941 stc->octetstring_st = new OctetstringConstraint(size_constraint);
942 break;
943 case ST_CHARSTRING:
944 if (char_context) {
945 if (size_constraint.is_equal(SizeRangeListConstraint(size_limit_t(1)))==TFALSE) {
946 loc->error("Only SIZE(1) constraint can be used inside a permitted alphabet constraint");
947 delete stc;
948 return NULL;
949 }
950 // SIZE(1) is allowed in char context, it means ALL
951 } else {
952 stc->charstring_st = new CharstringSubtypeTreeElement(size_constraint);
953 }
954 break;
955 case ST_UNIVERSAL_CHARSTRING:
956 if (char_context) {
957 if (size_constraint.is_equal(SizeRangeListConstraint(size_limit_t(1)))==TFALSE) {
958 loc->error("Only SIZE(1) constraint can be used inside a permitted alphabet constraint");
959 delete stc;
960 return NULL;
961 }
962 // SIZE(1) is allowed in char context, it means ALL
963 } else {
964 stc->universal_charstring_st = new UniversalCharstringSubtypeTreeElement(size_constraint);
965 }
966 break;
967 case ST_RECORDOF:
968 case ST_SETOF:
969 stc->recof_st = new RecofConstraint(size_constraint);
970 break;
971 default:
972 loc->error("Size constraint is not allowed for type `%s'", type->get_typename().c_str());
973 delete stc;
974 return NULL;
975 }
976 return stc;
977}
978
979SubtypeConstraint* SubtypeConstraint::create_permitted_alphabet_constraint(
980 SubtypeConstraint* stc, bool char_context, Type* type, Location* loc)
981{
982 if (char_context) {
983 loc->error("Permitted alphabet constraint not allowed inside a permitted alphabet constraint");
984 return NULL;
985 }
986 subtype_t st_t = type->get_subtype_type();
987 switch (st_t) {
988 case ST_CHARSTRING:
989 case ST_UNIVERSAL_CHARSTRING: {
990 if (stc==NULL) return NULL; // error was reported there
991 if (st_t!=stc->get_subtypetype()) FATAL_ERROR("SubtypeConstraint::create_permitted_alphabet_constraint()");
992 SubtypeConstraint* rv_stc = new SubtypeConstraint(st_t);
993 if (st_t==ST_CHARSTRING) {
994 if (stc->charstring_st) {
995 rv_stc->charstring_st = new CharstringSubtypeTreeElement(*(stc->charstring_st));
996 rv_stc->charstring_st->set_char_context(false);
997 }
998 } else {
999 if (stc->universal_charstring_st) {
1000 rv_stc->universal_charstring_st = new UniversalCharstringSubtypeTreeElement(*(stc->universal_charstring_st));
1001 rv_stc->universal_charstring_st->set_char_context(false);
1002 }
1003 }
1004 return rv_stc;
1005 } break;
1006 case ST_ERROR:
1007 // error already reported
1008 break;
1009 default:
1010 loc->error("Permitted alphabet constraint is not allowed for type `%s'", type->get_typename().c_str());
1011 break;
1012 }
1013 return NULL;
1014}
1015
1016void SubtypeConstraint::set_to_error()
1017{
1018 switch (subtype) {
1019 case ST_ERROR:
1020 break;
1021 case ST_INTEGER:
1022 delete integer_st;
1023 break;
1024 case ST_FLOAT:
1025 delete float_st;
1026 break;
1027 case ST_BOOLEAN:
1028 delete boolean_st;
1029 break;
1030 case ST_VERDICTTYPE:
1031 delete verdict_st;
1032 break;
1033 case ST_BITSTRING:
1034 delete bitstring_st;
1035 break;
1036 case ST_HEXSTRING:
1037 delete hexstring_st;
1038 break;
1039 case ST_OCTETSTRING:
1040 delete octetstring_st;
1041 break;
1042 case ST_CHARSTRING:
1043 delete charstring_st;
1044 break;
1045 case ST_UNIVERSAL_CHARSTRING:
1046 delete universal_charstring_st;
1047 break;
1048 case ST_OBJID:
1049 case ST_RECORD:
1050 case ST_SET:
1051 case ST_ENUM:
1052 case ST_UNION:
1053 case ST_FUNCTION:
1054 case ST_ALTSTEP:
1055 case ST_TESTCASE:
1056 delete value_st;
1057 break;
1058 case ST_RECORDOF:
1059 case ST_SETOF:
1060 delete recof_st;
1061 break;
1062 default:
1063 FATAL_ERROR("SubtypeConstraint::set_to_error()");
1064 }
1065 subtype = ST_ERROR;
1066 delete length_restriction;
1067 length_restriction = NULL;
1068}
1069
1070string SubtypeConstraint::to_string() const
1071{
1072 switch (subtype) {
1073 case ST_ERROR:
1074 return string("<error>");
1075 case ST_INTEGER:
1076 return (integer_st==NULL) ? string() : integer_st->to_string();
1077 case ST_FLOAT:
1078 return (float_st==NULL) ? string() : float_st->to_string();
1079 case ST_BOOLEAN:
1080 return (boolean_st==NULL) ? string() : boolean_st->to_string();
1081 case ST_VERDICTTYPE:
1082 return (verdict_st==NULL) ? string() : verdict_st->to_string();
1083 case ST_BITSTRING:
1084 return (bitstring_st==NULL) ? string() : bitstring_st->to_string();
1085 case ST_HEXSTRING:
1086 return (hexstring_st==NULL) ? string() : hexstring_st->to_string();
1087 case ST_OCTETSTRING:
1088 return (octetstring_st==NULL) ? string() : octetstring_st->to_string();
1089 case ST_CHARSTRING:
1090 return (charstring_st==NULL) ? string() : charstring_st->to_string();
1091 case ST_UNIVERSAL_CHARSTRING:
1092 return (universal_charstring_st==NULL) ? string() : universal_charstring_st->to_string();
1093 case ST_OBJID:
1094 case ST_RECORD:
1095 case ST_SET:
1096 case ST_ENUM:
1097 case ST_UNION:
1098 case ST_FUNCTION:
1099 case ST_ALTSTEP:
1100 case ST_TESTCASE:
1101 return (value_st==NULL) ? string() : value_st->to_string();
1102 case ST_RECORDOF:
1103 case ST_SETOF:
1104 return (recof_st==NULL) ? string() : recof_st->to_string();
1105 default:
1106 FATAL_ERROR("SubtypeConstraint::to_string()");
1107 }
1108}
1109
1110bool SubtypeConstraint::is_compatible(const SubtypeConstraint *p_st) const
1111{
1112 if (p_st==NULL) return true; // the other type has no subtype restriction
1113 if ( (subtype==ST_ERROR) || (p_st->subtype==ST_ERROR) ) return true;
1114 if (subtype!=p_st->subtype) FATAL_ERROR("SubtypeConstraint::is_compatible()");
1115 // if the resulting set.is_empty()==TUNKNOWN then remain silent
1116 switch (subtype) {
1117 case ST_INTEGER:
1118 if ((integer_st==NULL) || (p_st->integer_st==NULL)) return true;
1119 return ((*integer_st**(p_st->integer_st)).is_empty()!=TTRUE);
1120 case ST_FLOAT:
1121 if ((float_st==NULL) || (p_st->float_st==NULL)) return true;
1122 return ((*float_st**(p_st->float_st)).is_empty()!=TTRUE);
1123 case ST_BOOLEAN:
1124 if ((boolean_st==NULL) || (p_st->boolean_st==NULL)) return true;
1125 return ((*boolean_st**(p_st->boolean_st)).is_empty()!=TTRUE);
1126 case ST_VERDICTTYPE:
1127 if ((verdict_st==NULL) || (p_st->verdict_st==NULL)) return true;
1128 return ((*verdict_st**(p_st->verdict_st)).is_empty()!=TTRUE);
1129 case ST_BITSTRING:
1130 if ((bitstring_st==NULL) || (p_st->bitstring_st==NULL)) return true;
1131 return ((*bitstring_st**(p_st->bitstring_st)).is_empty()!=TTRUE);
1132 case ST_HEXSTRING:
1133 if ((hexstring_st==NULL) || (p_st->hexstring_st==NULL)) return true;
1134 return ((*hexstring_st**(p_st->hexstring_st)).is_empty()!=TTRUE);
1135 case ST_OCTETSTRING:
1136 if ((octetstring_st==NULL) || (p_st->octetstring_st==NULL)) return true;
1137 return ((*octetstring_st**(p_st->octetstring_st)).is_empty()!=TTRUE);
1138 case ST_CHARSTRING: {
1139 if ((charstring_st==NULL) || (p_st->charstring_st==NULL)) return true;
1140 CharstringSubtypeTreeElement* cc = new CharstringSubtypeTreeElement(
1141 CharstringSubtypeTreeElement::ET_INTERSECTION,
1142 new CharstringSubtypeTreeElement(*charstring_st),
1143 new CharstringSubtypeTreeElement(*(p_st->charstring_st))
1144 );
1145 bool rv = (cc->is_empty()!=TTRUE);
1146 delete cc;
1147 return rv;
1148 }
1149 case ST_UNIVERSAL_CHARSTRING: {
1150 if ((universal_charstring_st==NULL) || (p_st->universal_charstring_st==NULL)) return true;
1151 UniversalCharstringSubtypeTreeElement* ucc = new UniversalCharstringSubtypeTreeElement(
1152 UniversalCharstringSubtypeTreeElement::ET_INTERSECTION,
1153 new UniversalCharstringSubtypeTreeElement(*universal_charstring_st),
1154 new UniversalCharstringSubtypeTreeElement(*(p_st->universal_charstring_st))
1155 );
1156 bool rv = (ucc->is_empty()!=TTRUE);
1157 delete ucc;
1158 return rv;
1159 }
1160 case ST_OBJID:
1161 case ST_RECORD:
1162 case ST_SET:
1163 case ST_ENUM:
1164 case ST_UNION:
1165 case ST_FUNCTION:
1166 case ST_ALTSTEP:
1167 case ST_TESTCASE:
1168 if ((value_st==NULL) || (p_st->value_st==NULL)) return true;
1169 return ((*value_st**(p_st->value_st)).is_empty()!=TTRUE);
1170 case ST_RECORDOF:
1171 case ST_SETOF:
1172 if ((recof_st==NULL) || (p_st->recof_st==NULL)) return true;
1173 return ((*recof_st**(p_st->recof_st)).is_empty()!=TTRUE);
1174 default:
1175 FATAL_ERROR("SubtypeConstraint::is_compatible()");
1176 }
1177 return true;
1178}
1179
1180bool SubtypeConstraint::is_compatible_with_elem() const
1181{
1182 if (subtype==ST_ERROR) return true;
1183 switch (subtype) {
1184 case ST_BITSTRING: {
1185 static BitstringConstraint str_elem(size_limit_t(1));
1186 if (bitstring_st==NULL) return true;
1187 return ((*bitstring_st*str_elem).is_empty()!=TTRUE);
1188 }
1189 case ST_HEXSTRING: {
1190 static HexstringConstraint str_elem(size_limit_t(1));
1191 if (hexstring_st==NULL) return true;
1192 return ((*hexstring_st*str_elem).is_empty()!=TTRUE);
1193 }
1194 case ST_OCTETSTRING: {
1195 static OctetstringConstraint str_elem(size_limit_t(1));
1196 if (octetstring_st==NULL) return true;
1197 return ((*octetstring_st*str_elem).is_empty()!=TTRUE);
1198 }
1199 case ST_CHARSTRING: {
1200 size_limit_t t = size_limit_t(1);
1201 SizeRangeListConstraint temp = SizeRangeListConstraint(t);
1202 static CharstringSubtypeTreeElement str_elem(temp);
1203 if (charstring_st==NULL) return true;
1204 CharstringSubtypeTreeElement* cc = new CharstringSubtypeTreeElement(
1205 CharstringSubtypeTreeElement::ET_INTERSECTION,
1206 new CharstringSubtypeTreeElement(*charstring_st),
1207 new CharstringSubtypeTreeElement(str_elem)
1208 );
1209 bool rv = (cc->is_empty()!=TTRUE);
1210 delete cc;
1211 return rv;
1212 }
1213 case ST_UNIVERSAL_CHARSTRING: {
1214 size_limit_t t = size_limit_t(1);
1215 SizeRangeListConstraint temp = SizeRangeListConstraint(t);
1216 static UniversalCharstringSubtypeTreeElement str_elem(temp);
1217 if (universal_charstring_st==NULL) return true;
1218 UniversalCharstringSubtypeTreeElement* ucc = new UniversalCharstringSubtypeTreeElement(
1219 UniversalCharstringSubtypeTreeElement::ET_INTERSECTION,
1220 new UniversalCharstringSubtypeTreeElement(*universal_charstring_st),
1221 new UniversalCharstringSubtypeTreeElement(str_elem)
1222 );
1223 bool rv = (ucc->is_empty()!=TTRUE);
1224 delete ucc;
1225 return rv;
1226 }
1227 default:
1228 FATAL_ERROR("SubtypeConstraint::is_compatible_with_elem()");
1229 }
1230 return true;
1231}
1232
1233bool SubtypeConstraint::is_length_compatible(const SubtypeConstraint *p_st) const
1234{
1235 if (p_st==NULL) FATAL_ERROR("SubtypeConstraint::is_length_compatible()");
1236 if ((subtype==ST_ERROR) || (p_st->subtype==ST_ERROR)) return true;
1237 if (subtype != ST_RECORDOF && subtype != ST_SETOF &&
1238 p_st->subtype != ST_RECORDOF && p_st->subtype != ST_SETOF)
1239 FATAL_ERROR("SubtypeConstraint::is_length_compatible()");
1240 if (length_restriction==NULL || p_st->length_restriction==NULL) return true;
1241 return ((*length_restriction * *(p_st->length_restriction)).is_empty()!=TTRUE);
1242}
1243
af710487 1244bool SubtypeConstraint::is_upper_limit_infinity() const
1245{
1246 if (ST_INTEGER == subtype && integer_st) {
1247 return integer_st->is_upper_limit_infinity();
1248 }
1249 if (ST_FLOAT == subtype && float_st) {
1250 return float_st->is_upper_limit_infinity();
1251 }
1252 return false;
1253}
1254
1255bool SubtypeConstraint::is_lower_limit_infinity() const
1256{
1257 if (ST_INTEGER == subtype && integer_st) {
1258 return integer_st->is_lower_limit_infinity();
1259 }
1260
1261 if (ST_FLOAT == subtype && float_st) {
1262 return float_st->is_lower_limit_infinity();
1263 }
1264 return false;
1265}
1266
1267
970ed795
EL		 1268void SubtypeConstraint::except(const SubtypeConstraint* other)
1269{
1270 if (other==NULL) FATAL_ERROR("SubtypeConstraint::except()");
1271 if (subtype!=other->subtype) FATAL_ERROR("SubtypeConstraint::except()");
1272 switch (subtype) {
1273 case ST_INTEGER:
1274 if (other->integer_st==NULL) {
1275 if (integer_st==NULL) {
1276 integer_st = new IntegerRangeListConstraint();
1277 } else {
1278 *integer_st = IntegerRangeListConstraint();
1279 }
1280 } else {
1281 if (integer_st==NULL) {
1282 integer_st = new IntegerRangeListConstraint(~*(other->integer_st));
1283 } else {
1284 *integer_st = *integer_st - *(other->integer_st);
1285 }
1286 }
1287 break;
1288 case ST_FLOAT:
1289 if (other->float_st==NULL) {
1290 if (float_st==NULL) {
1291 float_st = new RealRangeListConstraint();
1292 } else {
1293 *float_st = RealRangeListConstraint();
1294 }
1295 } else {
1296 if (float_st==NULL) {
1297 float_st = new RealRangeListConstraint(~*(other->float_st));
1298 } else {
1299 *float_st = *float_st - *(other->float_st);
1300 }
1301 }
1302 break;
1303 case ST_BOOLEAN:
1304 if (other->boolean_st==NULL) {
1305 if (boolean_st==NULL) {
1306 boolean_st = new BooleanListConstraint();
1307 } else {
1308 *boolean_st = BooleanListConstraint();
1309 }
1310 } else {
1311 if (boolean_st==NULL) {
1312 boolean_st = new BooleanListConstraint(~*(other->boolean_st));
1313 } else {
1314 *boolean_st = *boolean_st - *(other->boolean_st);
1315 }
1316 }
1317 break;
1318 case ST_VERDICTTYPE:
1319 if (other->verdict_st==NULL) {
1320 if (verdict_st==NULL) {
1321 verdict_st = new VerdicttypeListConstraint();
1322 } else {
1323 *verdict_st = VerdicttypeListConstraint();
1324 }
1325 } else {
1326 if (verdict_st==NULL) {
1327 verdict_st = new VerdicttypeListConstraint(~*(other->verdict_st));
1328 } else {
1329 *verdict_st = *verdict_st - *(other->verdict_st);
1330 }
1331 }
1332 break;
1333 case ST_BITSTRING:
1334 if (other->bitstring_st==NULL) {
1335 if (bitstring_st==NULL) {
1336 bitstring_st = new BitstringConstraint();
1337 } else {
1338 *bitstring_st = BitstringConstraint();
1339 }
1340 } else {
1341 if (bitstring_st==NULL) {
1342 bitstring_st = new BitstringConstraint(~*(other->bitstring_st));
1343 } else {
1344 *bitstring_st = *bitstring_st - *(other->bitstring_st);
1345 }
1346 }
1347 break;
1348 case ST_HEXSTRING:
1349 if (other->hexstring_st==NULL) {
1350 if (hexstring_st==NULL) {
1351 hexstring_st = new HexstringConstraint();
1352 } else {
1353 *hexstring_st = HexstringConstraint();
1354 }
1355 } else {
1356 if (hexstring_st==NULL) {
1357 hexstring_st = new HexstringConstraint(~*(other->hexstring_st));
1358 } else {
1359 *hexstring_st = *hexstring_st - *(other->hexstring_st);
1360 }
1361 }
1362 break;
1363 case ST_OCTETSTRING:
1364 if (other->octetstring_st==NULL) {
1365 if (octetstring_st==NULL) {
1366 octetstring_st = new OctetstringConstraint();
1367 } else {
1368 *octetstring_st = OctetstringConstraint();
1369 }
1370 } else {
1371 if (octetstring_st==NULL) {
1372 octetstring_st = new OctetstringConstraint(~*(other->octetstring_st));
1373 } else {
1374 *octetstring_st = *octetstring_st - *(other->octetstring_st);
1375 }
1376 }
1377 break;
1378 case ST_CHARSTRING:
1379 if (other->charstring_st==NULL) {
1380 if (charstring_st==NULL) {
1381 charstring_st = new CharstringSubtypeTreeElement();
1382 } else {
1383 *charstring_st = CharstringSubtypeTreeElement();
1384 }
1385 } else {
1386 if (charstring_st==NULL) {
1387 CharstringSubtypeTreeElement* call_st = new CharstringSubtypeTreeElement();
1388 call_st->set_all();
1389 charstring_st = new CharstringSubtypeTreeElement(CharstringSubtypeTreeElement::ET_EXCEPT,
1390 call_st, new CharstringSubtypeTreeElement(*(other->charstring_st)));
1391 } else {
1392 charstring_st = new CharstringSubtypeTreeElement(CharstringSubtypeTreeElement::ET_EXCEPT,
1393 charstring_st, new CharstringSubtypeTreeElement(*(other->charstring_st)));
1394 }
1395 }
1396 break;
1397 case ST_UNIVERSAL_CHARSTRING:
1398 if (other->universal_charstring_st==NULL) {
1399 if (universal_charstring_st==NULL) {
1400 universal_charstring_st = new UniversalCharstringSubtypeTreeElement();
1401 } else {
1402 *universal_charstring_st = UniversalCharstringSubtypeTreeElement();
1403 }
1404 } else {
1405 if (universal_charstring_st==NULL) {
1406 UniversalCharstringSubtypeTreeElement* ucall_st = new UniversalCharstringSubtypeTreeElement();
1407 ucall_st->set_all();
1408 universal_charstring_st = new UniversalCharstringSubtypeTreeElement(UniversalCharstringSubtypeTreeElement::ET_EXCEPT,
1409 ucall_st, new UniversalCharstringSubtypeTreeElement(*(other->universal_charstring_st)));
1410 } else {
1411 universal_charstring_st = new UniversalCharstringSubtypeTreeElement(UniversalCharstringSubtypeTreeElement::ET_EXCEPT,
1412 universal_charstring_st, new UniversalCharstringSubtypeTreeElement(*(other->universal_charstring_st)));
1413 }
1414 }
1415 break;
1416 case ST_OBJID:
1417 case ST_RECORD:
1418 case ST_SET:
1419 case ST_ENUM:
1420 case ST_UNION:
1421 case ST_FUNCTION:
1422 case ST_ALTSTEP:
1423 case ST_TESTCASE:
1424 if (other->value_st==NULL) {
1425 if (value_st==NULL) {
1426 value_st = new ValueListConstraint();
1427 } else {
1428 *value_st = ValueListConstraint();
1429 }
1430 } else {
1431 if (value_st==NULL) {
1432 value_st = new ValueListConstraint(~*(other->value_st));
1433 } else {
1434 *value_st = *value_st - *(other->value_st);
1435 }
1436 }
1437 break;
1438 case ST_RECORDOF:
1439 case ST_SETOF:
1440 if (other->recof_st==NULL) {
1441 if (recof_st==NULL) {
1442 recof_st = new RecofConstraint();
1443 } else {
1444 *recof_st = RecofConstraint();
1445 }
1446 } else {
1447 if (recof_st==NULL) {
1448 recof_st = new RecofConstraint(~*(other->recof_st));
1449 } else {
1450 *recof_st = *recof_st - *(other->recof_st);
1451 }
1452 }
1453 break;
1454 default:
1455 FATAL_ERROR("SubtypeConstraint::except()");
1456 }
1457 if (other->length_restriction==NULL) {
1458 if (length_restriction==NULL) {
1459 length_restriction = new SizeRangeListConstraint();
1460 } else {
1461 *length_restriction = SizeRangeListConstraint();
1462 }
1463 } else {
1464 if (length_restriction==NULL) {
1465 length_restriction = new SizeRangeListConstraint(~*(other->length_restriction));
1466 } else {
1467 *length_restriction = *length_restriction - *(other->length_restriction);
1468 }
1469 }
1470}
1471
1472void SubtypeConstraint::union_(const SubtypeConstraint* other)
1473{
1474 if (other==NULL) FATAL_ERROR("SubtypeConstraint::union_()");
1475 if (subtype!=other->subtype) FATAL_ERROR("SubtypeConstraint::union_()");
1476 switch (subtype) {
1477 case ST_INTEGER:
1478 if (integer_st==NULL) break;
1479 if (other->integer_st==NULL) { delete integer_st; integer_st = NULL; break; }
1480 *integer_st = *integer_st + *(other->integer_st);
1481 break;
1482 case ST_FLOAT:
1483 if (float_st==NULL) break;
1484 if (other->float_st==NULL) { delete float_st; float_st = NULL; break; }
1485 *float_st = *float_st + *(other->float_st);
1486 break;
1487 case ST_BOOLEAN:
1488 if (boolean_st==NULL) break;
1489 if (other->boolean_st==NULL) { delete boolean_st; boolean_st = NULL; break; }
1490 *boolean_st = *boolean_st + *(other->boolean_st);
1491 break;
1492 case ST_VERDICTTYPE:
1493 if (verdict_st==NULL) break;
1494 if (other->verdict_st==NULL) { delete verdict_st; verdict_st = NULL; break; }
1495 *verdict_st = *verdict_st + *(other->verdict_st);
1496 break;
1497 case ST_BITSTRING:
1498 if (bitstring_st==NULL) break;
1499 if (other->bitstring_st==NULL) { delete bitstring_st; bitstring_st = NULL; break; }
1500 *bitstring_st = *bitstring_st + *(other->bitstring_st);
1501 break;
1502 case ST_HEXSTRING:
1503 if (hexstring_st==NULL) break;
1504 if (other->hexstring_st==NULL) { delete hexstring_st; hexstring_st = NULL; break; }
1505 *hexstring_st = *hexstring_st + *(other->hexstring_st);
1506 break;
1507 case ST_OCTETSTRING:
1508 if (octetstring_st==NULL) break;
1509 if (other->octetstring_st==NULL) { delete octetstring_st; octetstring_st = NULL; break; }
1510 *octetstring_st = *octetstring_st + *(other->octetstring_st);
1511 break;
1512 case ST_CHARSTRING:
1513 if (charstring_st==NULL) break;
1514 if (other->charstring_st==NULL) { delete charstring_st; charstring_st = NULL; break; }
1515 charstring_st = new CharstringSubtypeTreeElement(CharstringSubtypeTreeElement::ET_UNION,
1516 charstring_st, new CharstringSubtypeTreeElement(*(other->charstring_st)));
1517 break;
1518 case ST_UNIVERSAL_CHARSTRING:
1519 if (universal_charstring_st==NULL) break;
1520 if (other->universal_charstring_st==NULL) { delete universal_charstring_st; universal_charstring_st = NULL; break; }
1521 universal_charstring_st = new UniversalCharstringSubtypeTreeElement(UniversalCharstringSubtypeTreeElement::ET_UNION,
1522 universal_charstring_st, new UniversalCharstringSubtypeTreeElement(*(other->universal_charstring_st)));
1523 break;
1524 case ST_OBJID:
1525 case ST_RECORD:
1526 case ST_SET:
1527 case ST_ENUM:
1528 case ST_UNION:
1529 case ST_FUNCTION:
1530 case ST_ALTSTEP:
1531 case ST_TESTCASE:
1532 if (value_st==NULL) break;
1533 if (other->value_st==NULL) { delete value_st; value_st = NULL; break; }
1534 *value_st = *value_st + *(other->value_st);
1535 break;
1536 case ST_RECORDOF:
1537 case ST_SETOF:
1538 if (recof_st==NULL) break;
1539 if (other->recof_st==NULL) { delete recof_st; recof_st = NULL; break; }
1540 *recof_st = *recof_st + *(other->recof_st);
1541 break;
1542 default:
1543 FATAL_ERROR("SubtypeConstraint::union_()");
1544 }
1545 if (length_restriction!=NULL) {
1546 if (other->length_restriction==NULL) {
1547 delete length_restriction;
1548 length_restriction = NULL;
1549 } else {
1550 *length_restriction = *length_restriction + *(other->length_restriction);
1551 }
1552 }
1553}
1554
1555void SubtypeConstraint::intersection(const SubtypeConstraint* other)
1556{
1557 if (other==NULL) FATAL_ERROR("SubtypeConstraint::intersection()");
1558 if (subtype!=other->subtype) FATAL_ERROR("SubtypeConstraint::intersection()");
1559 switch (subtype) {
1560 case ST_INTEGER:
1561 if (other->integer_st!=NULL) {
1562 if (integer_st==NULL) {
1563 integer_st = new IntegerRangeListConstraint(*(other->integer_st));
1564 } else {
1565 *integer_st = *integer_st * *(other->integer_st);
1566 }
1567 }
1568 break;
1569 case ST_FLOAT:
1570 if (other->float_st!=NULL) {
1571 if (float_st==NULL) {
1572 float_st = new RealRangeListConstraint(*(other->float_st));
1573 } else {
1574 *float_st = *float_st * *(other->float_st);
1575 }
1576 }
1577 break;
1578 case ST_BOOLEAN:
1579 if (other->boolean_st!=NULL) {
1580 if (boolean_st==NULL) {
1581 boolean_st = new BooleanListConstraint(*(other->boolean_st));
1582 } else {
1583 *boolean_st = *boolean_st * *(other->boolean_st);
1584 }
1585 }
1586 break;
1587 case ST_VERDICTTYPE:
1588 if (other->verdict_st!=NULL) {
1589 if (verdict_st==NULL) {
1590 verdict_st = new VerdicttypeListConstraint(*(other->verdict_st));
1591 } else {
1592 *verdict_st = *verdict_st * *(other->verdict_st);
1593 }
1594 }
1595 break;
1596 case ST_BITSTRING:
1597 if (other->bitstring_st!=NULL) {
1598 if (bitstring_st==NULL) {
1599 bitstring_st = new BitstringConstraint(*(other->bitstring_st));
1600 } else {
1601 *bitstring_st = *bitstring_st * *(other->bitstring_st);
1602 }
1603 }
1604 break;
1605 case ST_HEXSTRING:
1606 if (other->hexstring_st!=NULL) {
1607 if (hexstring_st==NULL) {
1608 hexstring_st = new HexstringConstraint(*(other->hexstring_st));
1609 } else {
1610 *hexstring_st = *hexstring_st * *(other->hexstring_st);
1611 }
1612 }
1613 break;
1614 case ST_OCTETSTRING:
1615 if (other->octetstring_st!=NULL) {
1616 if (octetstring_st==NULL) {
1617 octetstring_st = new OctetstringConstraint(*(other->octetstring_st));
1618 } else {
1619 *octetstring_st = *octetstring_st * *(other->octetstring_st);
1620 }
1621 }
1622 break;
1623 case ST_CHARSTRING:
1624 if (other->charstring_st!=NULL) {
1625 if (charstring_st==NULL) {
1626 charstring_st = new CharstringSubtypeTreeElement(*(other->charstring_st));
1627 } else {
1628 charstring_st = new CharstringSubtypeTreeElement(CharstringSubtypeTreeElement::ET_INTERSECTION,
1629 charstring_st, new CharstringSubtypeTreeElement(*(other->charstring_st)));
1630 }
1631 }
1632 break;
1633 case ST_UNIVERSAL_CHARSTRING:
1634 if (other->universal_charstring_st!=NULL) {
1635 if (universal_charstring_st==NULL) {
1636 universal_charstring_st = new UniversalCharstringSubtypeTreeElement(*(other->universal_charstring_st));
1637 } else {
1638 universal_charstring_st = new UniversalCharstringSubtypeTreeElement(UniversalCharstringSubtypeTreeElement::ET_INTERSECTION,
1639 universal_charstring_st, new UniversalCharstringSubtypeTreeElement(*(other->universal_charstring_st)));
1640 }
1641 }
1642 break;
1643 case ST_OBJID:
1644 case ST_RECORD:
1645 case ST_SET:
1646 case ST_ENUM:
1647 case ST_UNION:
1648 case ST_FUNCTION:
1649 case ST_ALTSTEP:
1650 case ST_TESTCASE:
1651 if (other->value_st!=NULL) {
1652 if (value_st==NULL) {
1653 value_st = new ValueListConstraint(*(other->value_st));
1654 } else {
1655 *value_st = *value_st * *(other->value_st);
1656 }
1657 }
1658 break;
1659 case ST_RECORDOF:
1660 case ST_SETOF:
1661 if (other->recof_st!=NULL) {
1662 if (recof_st==NULL) {
1663 recof_st = new RecofConstraint(*(other->recof_st));
1664 } else {
1665 *recof_st = *recof_st * *(other->recof_st);
1666 }
1667 }
1668 break;
1669 default:
1670 FATAL_ERROR("SubtypeConstraint::intersection()");
1671 }
1672 if (other->length_restriction!=NULL) {
1673 if (length_restriction==NULL) {
1674 length_restriction = new SizeRangeListConstraint(*(other->length_restriction));
1675 } else {
1676 *length_restriction = *length_restriction * *(other->length_restriction);
1677 }
1678 }
1679}
1680
1681tribool SubtypeConstraint::is_subset(const SubtypeConstraint* other) const
1682{
1683 if (other==NULL) return TTRUE;
1684 if (other->subtype!=subtype) FATAL_ERROR("SubtypeConstraint::is_subset()");
1685 switch (subtype) {
1686 case ST_INTEGER:
1687 if (other->integer_st==NULL) return TTRUE;
1688 return integer_st ? integer_st->is_subset(*(other->integer_st)) : TTRUE;
1689 case ST_FLOAT:
1690 if (other->float_st==NULL) return TTRUE;
1691 return float_st ? float_st->is_subset(*(other->float_st)) : TTRUE;
1692 case ST_BOOLEAN:
1693 if (other->boolean_st==NULL) return TTRUE;
1694 return boolean_st ? boolean_st->is_subset(*(other->boolean_st)) : TTRUE;
1695 case ST_VERDICTTYPE:
1696 if (other->verdict_st==NULL) return TTRUE;
1697 return verdict_st ? verdict_st->is_subset(*(other->verdict_st)) : TTRUE;
1698 case ST_BITSTRING:
1699 if (other->bitstring_st==NULL) return TTRUE;
1700 return bitstring_st ? bitstring_st->is_subset(*(other->bitstring_st)) : TTRUE;
1701 case ST_HEXSTRING:
1702 if (other->hexstring_st==NULL) return TTRUE;
1703 return hexstring_st ? hexstring_st->is_subset(*(other->hexstring_st)) : TTRUE;
1704 case ST_OCTETSTRING:
1705 if (other->octetstring_st==NULL) return TTRUE;
1706 return octetstring_st ? octetstring_st->is_subset(*(other->octetstring_st)) : TTRUE;
1707 case ST_CHARSTRING:
1708 if (other->charstring_st==NULL) return TTRUE;
1709 return charstring_st ? charstring_st->is_subset(other->charstring_st) : TTRUE;
1710 case ST_UNIVERSAL_CHARSTRING:
1711 if (other->universal_charstring_st==NULL) return TTRUE;
1712 return universal_charstring_st ? universal_charstring_st->is_subset(other->universal_charstring_st) : TTRUE;
1713 case ST_OBJID:
1714 case ST_RECORD:
1715 case ST_SET:
1716 case ST_ENUM:
1717 case ST_UNION:
1718 case ST_FUNCTION:
1719 case ST_ALTSTEP:
1720 case ST_TESTCASE:
1721 if (other->value_st==NULL) return TTRUE;
1722 return value_st ? value_st->is_subset(*(other->value_st)) : TTRUE;
1723 case ST_RECORDOF:
1724 case ST_SETOF:
1725 if (other->recof_st==NULL) return TTRUE;
1726 return recof_st ? recof_st->is_subset(*(other->recof_st)) : TTRUE;
1727 default:
1728 FATAL_ERROR("SubtypeConstraint::is_subset()");
1729 }
1730 return TUNKNOWN;
1731}
1732
1733/********************
1734class SubType
1735********************/
1736
1737SubType::SubType(subtype_t st, Type *p_my_owner, SubType* p_parent_subtype,
1738 vector<SubTypeParse> *p_parsed, Constraints* p_asn_constraints)
1739: SubtypeConstraint(st), my_owner(p_my_owner), parent_subtype(p_parent_subtype)
1740, parsed(p_parsed), asn_constraints(p_asn_constraints)
1741, root(0), extendable(false), extension(0), checked(STC_NO)
1742, my_parents()
1743{
1744 if (p_my_owner==NULL) FATAL_ERROR("SubType::SubType()");
1745}
1746
1747SubType::~SubType()
1748{
1749 my_parents.clear();
1750}
1751
1752void SubType::chk_this_value(Value *value)
1753{
1754 if (checked==STC_NO) FATAL_ERROR("SubType::chk_this_value()");
1755 if ((checked==STC_CHECKING) || (subtype==ST_ERROR)) return;
1756 Value *val = value->get_value_refd_last();
1757 bool is_invalid = false;
1758 switch (val->get_valuetype()) {
1759 case Value::V_INT:
1760 if (subtype!=ST_INTEGER) FATAL_ERROR("SubType::chk_this_value()");
1761 is_invalid = (integer_st!=NULL) && !integer_st->is_element(int_limit_t(*(val->get_val_Int())));
1762 break;
1763 case Value::V_REAL:
1764 if (subtype!=ST_FLOAT) FATAL_ERROR("SubType::chk_this_value()");
1765 is_invalid = (float_st!=NULL) && !float_st->is_element(val->get_val_Real());
1766 break;
1767 case Value::V_BOOL:
1768 if (subtype!=ST_BOOLEAN) FATAL_ERROR("SubType::chk_this_value()");
1769 is_invalid = (boolean_st!=NULL) && !boolean_st->is_element(val->get_val_bool());
1770 break;
1771 case Value::V_VERDICT: {
1772 if (subtype!=ST_VERDICTTYPE) FATAL_ERROR("SubType::chk_this_value()");
1773 VerdicttypeListConstraint::verdicttype_constraint_t vtc;
1774 switch (val->get_val_verdict()) {
1775 case Value::Verdict_NONE: vtc = VerdicttypeListConstraint::VC_NONE; break;
1776 case Value::Verdict_PASS: vtc = VerdicttypeListConstraint::VC_PASS; break;
1777 case Value::Verdict_INCONC: vtc = VerdicttypeListConstraint::VC_INCONC; break;
1778 case Value::Verdict_FAIL: vtc = VerdicttypeListConstraint::VC_FAIL; break;
1779 case Value::Verdict_ERROR: vtc = VerdicttypeListConstraint::VC_ERROR; break;
1780 default: FATAL_ERROR("SubType::chk_this_value()");
1781 }
1782 is_invalid = (verdict_st!=NULL) && !verdict_st->is_element(vtc);
1783 } break;
1784 case Value::V_BSTR:
1785 if (subtype!=ST_BITSTRING) FATAL_ERROR("SubType::chk_this_value()");
1786 is_invalid = (bitstring_st!=NULL) && !bitstring_st->is_element(val->get_val_str());
1787 break;
1788 case Value::V_HSTR:
1789 if (subtype!=ST_HEXSTRING) FATAL_ERROR("SubType::chk_this_value()");
1790 is_invalid = (hexstring_st!=NULL) && !hexstring_st->is_element(val->get_val_str());
1791 break;
1792 case Value::V_OSTR:
1793 if (subtype!=ST_OCTETSTRING) FATAL_ERROR("SubType::chk_this_value()");
1794 is_invalid = (octetstring_st!=NULL) && !octetstring_st->is_element(val->get_val_str());
1795 break;
1796 case Value::V_CSTR:
1797 case Value::V_ISO2022STR:
1798 if (subtype!=ST_CHARSTRING) FATAL_ERROR("SubType::chk_this_value()");
1799 is_invalid = (charstring_st!=NULL) && !charstring_st->is_element(val->get_val_str());
1800 break;
1801 case Value::V_USTR:
1802 case Value::V_CHARSYMS:
1803 if (subtype!=ST_UNIVERSAL_CHARSTRING) FATAL_ERROR("SubType::chk_this_value()");
1804 is_invalid = (universal_charstring_st!=NULL) && !universal_charstring_st->is_element(val->get_val_ustr());
1805 break;
1806 case Value::V_SEQOF:
1807 if (subtype!=ST_RECORDOF) FATAL_ERROR("SubType::chk_this_value()");
1808 if (value->is_unfoldable()) return;
1809 is_invalid = (recof_st!=NULL) && !recof_st->is_element(val);
1810 break;
1811 case Value::V_SETOF:
1812 if (subtype!=ST_SETOF) FATAL_ERROR("SubType::chk_this_value()");
1813 if (value->is_unfoldable()) return;
1814 is_invalid = (recof_st!=NULL) && !recof_st->is_element(val);
1815 break;
1816 case Value::V_OID:
1817 case Value::V_ROID:
1818 if (subtype!=ST_OBJID) FATAL_ERROR("SubType::chk_this_value()");
1819 if (value->is_unfoldable()) return;
1820 is_invalid = (value_st!=NULL) && !value_st->is_element(val);
1821 break;
1822 case Value::V_ENUM:
1823 case Value::V_NULL: // FIXME: should go to ST_NULL
1824 if (subtype!=ST_ENUM) FATAL_ERROR("SubType::chk_this_value()");
1825 if (value->is_unfoldable()) return;
1826 is_invalid = (value_st!=NULL) && !value_st->is_element(val);
1827 break;
1828 case Value::V_CHOICE:
1829 case Value::V_OPENTYPE: // FIXME?
1830 if (subtype!=ST_UNION) FATAL_ERROR("SubType::chk_this_value()");
1831 if (value->is_unfoldable()) return;
1832 is_invalid = (value_st!=NULL) && !value_st->is_element(val);
1833 break;
1834 case Value::V_SEQ:
1835 if (subtype!=ST_RECORD) FATAL_ERROR("SubType::chk_this_value()");
1836 if (value->is_unfoldable()) return;
1837 is_invalid = (value_st!=NULL) && !value_st->is_element(val);
1838 break;
1839 case Value::V_SET:
1840 if (subtype!=ST_SET) FATAL_ERROR("SubType::chk_this_value()");
1841 if (value->is_unfoldable()) return;
1842 is_invalid = (value_st!=NULL) && !value_st->is_element(val);
1843 break;
1844 case Value::V_FUNCTION:
1845 if (subtype!=ST_FUNCTION) FATAL_ERROR("SubType::chk_this_value()");
1846 if (value->is_unfoldable()) return;
1847 is_invalid = (value_st!=NULL) && !value_st->is_element(val);
1848 break;
1849 case Value::V_ALTSTEP:
1850 if (subtype!=ST_ALTSTEP) FATAL_ERROR("SubType::chk_this_value()");
1851 if (value->is_unfoldable()) return;
1852 is_invalid = (value_st!=NULL) && !value_st->is_element(val);
1853 break;
1854 case Value::V_TESTCASE:
1855 if (subtype!=ST_TESTCASE) FATAL_ERROR("SubType::chk_this_value()");
1856 if (value->is_unfoldable()) return;
1857 is_invalid = (value_st!=NULL) && !value_st->is_element(val);
1858 break;
1859 case Value::V_ERROR:
1860 return;
1861 default:
1862 return;
1863 }
1864 if (is_invalid) {
1865 value->error("%s is not a valid value for type `%s' which has subtype %s",
1866 val->get_stringRepr().c_str(),
1867 my_owner->get_typename().c_str(),
1868 to_string().c_str());
1869 }
1870}
1871
1872/** \todo revise */
1873void SubType::chk_this_template_generic(Template *templ)
1874{
1875 if (checked==STC_NO) FATAL_ERROR("SubType::chk_this_template_generic()");
1876 if ((checked==STC_CHECKING) || (subtype==ST_ERROR)) return;
1877 templ = templ->get_template_refd_last();
1878 switch (templ->get_templatetype()) {
1879 case Ttcn::Template::OMIT_VALUE:
1880 case Ttcn::Template::ANY_OR_OMIT:
1881 case Ttcn::Template::TEMPLATE_ERROR:
1882 case Ttcn::Template::ANY_VALUE:
1883 break;
1884 case Ttcn::Template::VALUE_LIST:
1885 case Ttcn::Template::COMPLEMENTED_LIST:
1886 /* Should be canonical before */
1887 break;
1888 case Ttcn::Template::SPECIFIC_VALUE:
1889 /* SPECIFIC_VALUE must be already checked in Type::chk_this_template() */
1890 break;
1891 case Ttcn::Template::TEMPLATE_REFD:
1892 /* unfoldable reference: cannot be checked at compile time */
1893 break;
1894 case Ttcn::Template::TEMPLATE_INVOKE:
1895 /* should be already checked in Type::chk_this_template() */
1896 break;
1897 default:
1898 chk_this_template(templ);
1899 break;
1900 }
1901 chk_this_template_length_restriction(templ);
1902}
1903
1904/** \todo revise */
1905void SubType::chk_this_template(Template *templ)
1906{
1907 switch (templ->get_templatetype()) {
1908 case Template::TEMPLATE_LIST:
1909 if ( (length_restriction!=NULL) && !length_restriction->is_empty() ) {
1910 size_t nof_comp_woaon = templ->get_nof_comps_not_anyornone();
1911 if (!templ->temps_contains_anyornone_symbol() &&
1912 nof_comp_woaon < length_restriction->get_minimal().get_size()) {
1913 templ->error("At least %s elements must be present in the list",
1914 Int2string((Int)(length_restriction->get_minimal().get_size())).c_str());
1915 return;
1916 } else if ( !length_restriction->get_maximal().get_infinity() && (nof_comp_woaon > length_restriction->get_maximal().get_size()) ) {
1917 templ->error("There must not be more than %s elements in the list",
1918 Int2string((Int)(length_restriction->get_maximal().get_size())).c_str());
1919 return;
1920 }
1921 }
1922 break;
1923 /* Simply break. We don't know how many elements are there.
1924 SUPERSET_MATCH/SUBSET_MATCH is not possible to be an
1925 INDEXED_TEMPLATE_LIST. */
1926 case Template::INDEXED_TEMPLATE_LIST:
1927 break;
1928 case Template::NAMED_TEMPLATE_LIST:
1929 break;
1930 case Template::VALUE_RANGE:
1931 /* Should be canonical before */
1932 break;
a38c6d4c 1933 case Template::ALL_FROM:
1934 case Template::VALUE_LIST_ALL_FROM:
1935 break;
970ed795
EL		 1936 case Template::SUPERSET_MATCH:
1937 case Template::SUBSET_MATCH:
1938 if (subtype!=ST_SETOF){
1939 templ->error("'subset' template matching mechanism can be used "
1940 "only with 'set of' types");
1941 return;
1942 }
1943 for (size_t i=0;i<templ->get_nof_comps();i++)
1944 chk_this_template_generic(templ->get_temp_byIndex(i));
1945 break;
1946 case Template::BSTR_PATTERN:
1947 chk_this_template_pattern("bitstring", templ);
1948 break;
1949 case Template::HSTR_PATTERN:
1950 chk_this_template_pattern("hexstring", templ);
1951 break;
1952 case Template::OSTR_PATTERN:
1953 chk_this_template_pattern("octetstring", templ);
1954 break;
1955 case Template::CSTR_PATTERN:
1956 chk_this_template_pattern("charstring", templ);
1957 break;
1958 case Template::USTR_PATTERN:
1959 chk_this_template_pattern("universal charstring", templ);
1960 break;
1961 case Template::TEMPLATE_ERROR:
1962 break;
1963 default:
1964 FATAL_ERROR("SubType::chk_this_template()");
1965 break;
1966 }
1967}
1968
1969void SubType::chk_this_template_length_restriction(Template *templ)
1970{
1971 if (!templ->is_length_restricted()) return;
1972 // if there is a length restriction on the template then check if
1973 // the intersection of the two restrictions is not empty
1974 size_limit_t tmpl_min_len(size_limit_t(0));
1975 size_limit_t tmpl_max_len(size_limit_t::INFINITE_SIZE);
1976 Ttcn::LengthRestriction *lr=templ->get_length_restriction();
1977 lr->chk(Type::EXPECTED_DYNAMIC_VALUE);
1978 if (!lr->get_is_range()) { //Template's lr is single
1979 Value *tmp_val=lr->get_single_value();
1980 if (tmp_val->get_valuetype()!=Value::V_INT) return;
1981 Int templ_len = tmp_val->get_val_Int()->get_val();
1982 tmpl_min_len = tmpl_max_len = size_limit_t((size_t)templ_len);
1983 } else { //Template's lr is range
1984 Value *tmp_lower=lr->get_lower_value();
1985 if (tmp_lower->get_valuetype()!=Value::V_INT) return;
1986 Int templ_lower = tmp_lower->get_val_Int()->get_val();
1987 tmpl_min_len = size_limit_t((size_t)templ_lower);
1988 Value *tmp_upper=lr->get_upper_value();
1989 if (tmp_upper && tmp_upper->get_valuetype()!=Value::V_INT) return;
1990 if (tmp_upper) tmpl_max_len = size_limit_t((size_t)tmp_upper->get_val_Int()->get_val());
1991 }
1992
1993 bool is_err = false;
1994 switch (subtype) {
1995 case ST_BITSTRING:
1996 if (bitstring_st!=NULL) {
1997 BitstringConstraint bc = *bitstring_st * BitstringConstraint(tmpl_min_len,tmpl_max_len);
1998 if (bc.is_empty()==TTRUE) is_err = true;
1999 }
2000 break;
2001 case ST_HEXSTRING:
2002 if (hexstring_st!=NULL) {
2003 HexstringConstraint hc = *hexstring_st * HexstringConstraint(tmpl_min_len,tmpl_max_len);
2004 if (hc.is_empty()==TTRUE) is_err = true;
2005 }
2006 break;
2007 case ST_OCTETSTRING:
2008 if (octetstring_st!=NULL) {
2009 OctetstringConstraint oc = *octetstring_st * OctetstringConstraint(tmpl_min_len,tmpl_max_len);
2010 if (oc.is_empty()==TTRUE) is_err = true;
2011 }
2012 break;
2013 case ST_CHARSTRING:
2014 if (charstring_st!=NULL) {
2015 CharstringSubtypeTreeElement* cc = new CharstringSubtypeTreeElement(
2016 CharstringSubtypeTreeElement::ET_INTERSECTION,
2017 new CharstringSubtypeTreeElement(*charstring_st),
2018 new CharstringSubtypeTreeElement(SizeRangeListConstraint(tmpl_min_len,tmpl_max_len))
2019 );
2020 if (cc->is_empty()==TTRUE) is_err = true;
2021 delete cc;
2022 }
2023 break;
2024 case ST_UNIVERSAL_CHARSTRING:
2025 if (universal_charstring_st!=NULL) {
2026 UniversalCharstringSubtypeTreeElement* ucc = new UniversalCharstringSubtypeTreeElement(
2027 UniversalCharstringSubtypeTreeElement::ET_INTERSECTION,
2028 new UniversalCharstringSubtypeTreeElement(*universal_charstring_st),
2029 new UniversalCharstringSubtypeTreeElement(SizeRangeListConstraint(tmpl_min_len,tmpl_max_len))
2030 );
2031 if (ucc->is_empty()==TTRUE) is_err = true;
2032 delete ucc;
2033 }
2034 break;
2035 case ST_RECORDOF:
2036 case ST_SETOF:
2037 if (recof_st!=NULL) {
2038 RecofConstraint rc = *recof_st * RecofConstraint(tmpl_min_len,tmpl_max_len);
2039 if (rc.is_empty()==TTRUE) is_err = true;
2040 }
2041 break;
2042 default:
2043 break;
2044 }
2045 if (is_err) {
2046 templ->error("Template's length restriction %s is outside of the type's subtype constraint %s",
2047 SizeRangeListConstraint(tmpl_min_len,tmpl_max_len).to_string().c_str(), to_string().c_str());
2048 }
2049}
2050
2051void SubType::chk_this_template_pattern(const char *patt_type, Template *templ)
2052{
2053 Template::templatetype_t temptype= templ->get_templatetype();
2054 if ((temptype==Template::BSTR_PATTERN && subtype!=ST_BITSTRING) ||
2055 (temptype==Template::HSTR_PATTERN && subtype!=ST_HEXSTRING) ||
2056 (temptype==Template::OSTR_PATTERN && subtype!=ST_OCTETSTRING) ||
2057 (temptype==Template::CSTR_PATTERN && subtype!=ST_CHARSTRING) ||
2058 (temptype==Template::USTR_PATTERN && subtype!=ST_UNIVERSAL_CHARSTRING))
2059 {
2060 templ->error("Template is incompatible with subtype");
2061 return;
2062 }
2063 if ( (length_restriction!=NULL) && !length_restriction->is_empty() ) {
2064 Int patt_min_len = static_cast<Int>(templ->get_min_length_of_pattern());
2065 if (patt_min_len < (Int)(length_restriction->get_minimal().get_size()) &&
2066 !templ->pattern_contains_anyornone_symbol()) {
2067 templ->error("At least %s string elements must be present in the %s",
2068 Int2string((Int)(length_restriction->get_minimal().get_size())).c_str(), patt_type);
2069 } else if ( !length_restriction->get_maximal().get_infinity() && (patt_min_len > (Int)(length_restriction->get_maximal().get_size())) ) {
2070 templ->error("There must not be more than %s string elements in the %s",
2071 Int2string((Int)(length_restriction->get_maximal().get_size())).c_str(), patt_type);
2072 }
2073 }
2074}
2075
2076void SubType::add_ttcn_value(Value *v)
2077{
2078 if (value_st==NULL) value_st = new ValueListConstraint(v);
2079 else *value_st = *value_st + ValueListConstraint(v);
2080}
2081
2082void SubType::add_ttcn_recof(Value *v)
2083{
2084 if (recof_st==NULL) recof_st = new RecofConstraint(v);
2085 else *recof_st = *recof_st + RecofConstraint(v);
2086}
2087
2088bool SubType::add_ttcn_type_list_subtype(SubType* p_st)
2089{
2090 switch (subtype) {
2091 case ST_INTEGER:
2092 if (p_st->integer_st==NULL) return false;
2093 if (integer_st==NULL) integer_st = new IntegerRangeListConstraint(*(p_st->integer_st));
2094 else *integer_st = *integer_st + *(p_st->integer_st);
2095 break;
2096 case ST_FLOAT:
2097 if (p_st->float_st==NULL) return false;
2098 if (float_st==NULL) float_st = new RealRangeListConstraint(*(p_st->float_st));
2099 else *float_st = *float_st + *(p_st->float_st);
2100 break;
2101 case ST_BOOLEAN:
2102 if (p_st->boolean_st==NULL) return false;
2103 if (boolean_st==NULL) boolean_st = new BooleanListConstraint(*(p_st->boolean_st));
2104 else *boolean_st = *boolean_st + *(p_st->boolean_st);
2105 break;
2106 case ST_VERDICTTYPE:
2107 if (p_st->verdict_st==NULL) return false;
2108 if (verdict_st==NULL) verdict_st = new VerdicttypeListConstraint(*(p_st->verdict_st));
2109 else *verdict_st = *verdict_st + *(p_st->verdict_st);
2110 break;
2111 case ST_BITSTRING:
2112 if (p_st->bitstring_st==NULL) return false;
2113 if (bitstring_st==NULL) bitstring_st = new BitstringConstraint(*(p_st->bitstring_st));
2114 else *bitstring_st = *bitstring_st + *(p_st->bitstring_st);
2115 break;
2116 case ST_HEXSTRING:
2117 if (p_st->hexstring_st==NULL) return false;
2118 if (hexstring_st==NULL) hexstring_st = new HexstringConstraint(*(p_st->hexstring_st));
2119 else *hexstring_st = *hexstring_st + *(p_st->hexstring_st);
2120 break;
2121 case ST_OCTETSTRING:
2122 if (p_st->octetstring_st==NULL) return false;
2123 if (octetstring_st==NULL) octetstring_st = new OctetstringConstraint(*(p_st->octetstring_st));
2124 else *octetstring_st = *octetstring_st + *(p_st->octetstring_st);
2125 break;
2126 case ST_CHARSTRING:
2127 if (p_st->charstring_st==NULL) return false;
2128 if (charstring_st==NULL) {
2129 charstring_st = new CharstringSubtypeTreeElement(*(p_st->charstring_st));
2130 } else {
2131 charstring_st = new CharstringSubtypeTreeElement(
2132 CharstringSubtypeTreeElement::ET_UNION,
2133 charstring_st,
2134 new CharstringSubtypeTreeElement(*(p_st->charstring_st)));
2135 }
2136 break;
2137 case ST_UNIVERSAL_CHARSTRING:
2138 if (p_st->universal_charstring_st==NULL) return false;
2139 if (universal_charstring_st==NULL) {
2140 universal_charstring_st = new UniversalCharstringSubtypeTreeElement(*(p_st->universal_charstring_st));
2141 } else {
2142 universal_charstring_st = new UniversalCharstringSubtypeTreeElement(
2143 UniversalCharstringSubtypeTreeElement::ET_UNION,
2144 universal_charstring_st,
2145 new UniversalCharstringSubtypeTreeElement(*(p_st->universal_charstring_st)));
2146 }
2147 break;
2148 case ST_OBJID:
2149 case ST_RECORD:
2150 case ST_SET:
2151 case ST_ENUM:
2152 case ST_UNION:
2153 case ST_FUNCTION:
2154 case ST_ALTSTEP:
2155 case ST_TESTCASE:
2156 if (p_st->value_st==NULL) return false;
2157 if (value_st==NULL) value_st = new ValueListConstraint(*(p_st->value_st));
2158 else *value_st = *value_st + *(p_st->value_st);
2159 break;
2160 case ST_RECORDOF:
2161 case ST_SETOF:
2162 if (p_st->recof_st==NULL) return false;
2163 if (recof_st==NULL) recof_st = new RecofConstraint(*(p_st->recof_st));
2164 else *recof_st = *recof_st + *(p_st->recof_st);
2165 break;
2166 default:
2167 FATAL_ERROR("SubType::add_ttcn_type_list_subtype()");
2168 }
2169 return true;
2170}
2171
2172
2173bool SubType::add_parent_subtype(SubType* st)
2174{
2175 if (st==NULL) FATAL_ERROR("SubType::add_parent_subtype()");
2176 if (my_parents.has_key(st)) return true; // it was already successfully added -> ignore
2177 ReferenceChain refch(my_owner, "While checking circular type references in subtype definitions");
2178 refch.add(my_owner->get_fullname()); // current type
2179 // recursive check for all parents of referenced type
2180 if (!st->chk_recursion(refch)) return false;
2181 // if no recursion was detected then add the referenced type as parent
2182 my_parents.add(st,NULL);
2183 return true;
2184}
2185
2186bool SubType::chk_recursion(ReferenceChain& refch)
2187{
2188 if (!refch.add(my_owner->get_fullname())) return false; // try the referenced type
2189 for (size_t i = 0; i < my_parents.size(); i++) {
2190 refch.mark_state();
2191 if (!my_parents.get_nth_key(i)->chk_recursion(refch)) return false;
2192 refch.prev_state();
2193 }
2194 return true;
2195}
2196
2197bool SubType::add_ttcn_single(Value *val, size_t restriction_index)
2198{
2199 val->set_my_scope(my_owner->get_my_scope());
2200 val->set_my_governor(my_owner);
2201 val->set_fullname(my_owner->get_fullname()+".<single_restriction_"+Int2string(restriction_index) + ">");
2202 my_owner->chk_this_value_ref(val);
2203
2204 // check if this is type reference, if not then fall through
2205 if (val->get_valuetype()==Value::V_REFD) {
2206 Reference* ref = val->get_reference();
2207 Assignment *ass = ref->get_refd_assignment();
2208 if (ass==NULL) return false; // defintion was not found, error was reported
2209 if (ass->get_asstype()==Assignment::A_TYPE) {
2210 Type* t = ass->get_Type();
2211 t->chk();
2212 if (t->get_typetype()==Type::T_ERROR) return false;
2213 // if there were subreferences then get the referenced field's type
2214 if (ref->get_subrefs()) {
2215 t = t->get_field_type(ref->get_subrefs(), Type::EXPECTED_CONSTANT);
2216 if ( (t==NULL) || (t->get_typetype()==Type::T_ERROR) ) return false;
2217 t->chk();
2218 if (t->get_typetype()==Type::T_ERROR) return false;
2219 }
2220 if (!t->is_identical(my_owner)) {
2221 val->error("Reference `%s' must refer to a type which has the same root type as this type",
2222 val->get_reference()->get_dispname().c_str());
2223 return false;
2224 }
2225 // check subtype of referenced type
2226 SubType* t_st = t->get_sub_type();
2227 if (t_st==NULL) {
2228 val->error("Type referenced by `%s' does not have a subtype",
2229 val->get_reference()->get_dispname().c_str());
2230 return false;
2231 }
2232
2233 // check circular subtype reference
2234 if (!add_parent_subtype(t_st)) return false;
2235
2236 if (t_st->get_subtypetype()==ST_ERROR) return false;
2237 if (t_st->get_subtypetype()!=subtype) FATAL_ERROR("SubType::add_ttcn_single()");
2238 // add the subtype as union
2239 bool added = add_ttcn_type_list_subtype(t_st);
2240 if (!added) {
2241 val->error("Type referenced by `%s' does not have a subtype",
2242 val->get_reference()->get_dispname().c_str());
2243 }
2244 return added;
2245 }
2246 }
2247
2248 my_owner->chk_this_value(val, 0, Type::EXPECTED_CONSTANT,
2249 INCOMPLETE_NOT_ALLOWED, OMIT_NOT_ALLOWED, NO_SUB_CHK);
2250
2251 Value *v=val->get_value_refd_last();
2252
2253 switch (v->get_valuetype()) {
2254 case Value::V_INT:
2255 if (subtype!=ST_INTEGER) FATAL_ERROR("SubType::add_ttcn_single()");
2256 if (integer_st==NULL) integer_st = new IntegerRangeListConstraint(int_limit_t(*(v->get_val_Int())));
2257 else *integer_st = *integer_st + IntegerRangeListConstraint(int_limit_t(*(v->get_val_Int())));
2258 break;
2259 case Value::V_REAL: {
2260 if (subtype!=ST_FLOAT) FATAL_ERROR("SubType::add_ttcn_single()");
2261 ttcn3float r = v->get_val_Real();
2262 if (r!=r) {
2263 if (float_st==NULL) float_st = new RealRangeListConstraint(true);
2264 else *float_st = *float_st + RealRangeListConstraint(true);
2265 } else {
2266 if (float_st==NULL) float_st = new RealRangeListConstraint(real_limit_t(r));
2267 else *float_st = *float_st + RealRangeListConstraint(real_limit_t(r));
2268 }
2269 } break;
2270 case Value::V_BOOL:
2271 if (subtype!=ST_BOOLEAN) FATAL_ERROR("SubType::add_ttcn_single()");
2272 if (boolean_st==NULL) boolean_st = new BooleanListConstraint(v->get_val_bool());
2273 else *boolean_st = *boolean_st + BooleanListConstraint(v->get_val_bool());
2274 break;
2275 case Value::V_VERDICT: {
2276 if (subtype!=ST_VERDICTTYPE) FATAL_ERROR("SubType::add_ttcn_single()");
2277 VerdicttypeListConstraint::verdicttype_constraint_t vtc;
2278 switch (v->get_val_verdict()) {
2279 case Value::Verdict_NONE: vtc = VerdicttypeListConstraint::VC_NONE; break;
2280 case Value::Verdict_PASS: vtc = VerdicttypeListConstraint::VC_PASS; break;
2281 case Value::Verdict_INCONC: vtc = VerdicttypeListConstraint::VC_INCONC; break;
2282 case Value::Verdict_FAIL: vtc = VerdicttypeListConstraint::VC_FAIL; break;
2283 case Value::Verdict_ERROR: vtc = VerdicttypeListConstraint::VC_ERROR; break;
2284 default: FATAL_ERROR("SubType::add_ttcn_single()");
2285 }
2286 if (verdict_st==NULL) verdict_st = new VerdicttypeListConstraint(vtc);
2287 else *verdict_st = *verdict_st + VerdicttypeListConstraint(vtc);
2288 } break;
2289 case Value::V_OID:
2290 if (v->has_oid_error()) return false;
2291 if (subtype!=ST_OBJID) FATAL_ERROR("SubType::add_ttcn_single()");
2292 if (value_st==NULL) value_st = new ValueListConstraint(v);
2293 else *value_st = *value_st + ValueListConstraint(v);
2294 break;
2295 case Value::V_BSTR:
2296 if (subtype!=ST_BITSTRING) FATAL_ERROR("SubType::add_ttcn_single()");
2297 if (bitstring_st==NULL) bitstring_st = new BitstringConstraint(v->get_val_str());
2298 else *bitstring_st = *bitstring_st + BitstringConstraint(v->get_val_str());
2299 break;
2300 case Value::V_HSTR:
2301 if (subtype!=ST_HEXSTRING) FATAL_ERROR("SubType::add_ttcn_single()");
2302 if (hexstring_st==NULL) hexstring_st = new HexstringConstraint(v->get_val_str());
2303 else *hexstring_st = *hexstring_st + HexstringConstraint(v->get_val_str());
2304 break;
2305 case Value::V_OSTR:
2306 if (subtype!=ST_OCTETSTRING) FATAL_ERROR("SubType::add_ttcn_single()");
2307 if (octetstring_st==NULL) octetstring_st = new OctetstringConstraint(v->get_val_str());
2308 else *octetstring_st = *octetstring_st + OctetstringConstraint(v->get_val_str());
2309 break;
2310 case Value::V_CSTR: {
2311 if (subtype!=ST_CHARSTRING) FATAL_ERROR("SubType::add_ttcn_single()");
2312 CharstringSubtypeTreeElement* cst_elem = new CharstringSubtypeTreeElement(StringValueConstraint<string>(v->get_val_str()));
2313 if (charstring_st==NULL) charstring_st = cst_elem;
2314 else charstring_st = new CharstringSubtypeTreeElement(CharstringSubtypeTreeElement::ET_UNION, charstring_st, cst_elem);
2315 } break;
2316 case Value::V_USTR: {
2317 if (subtype!=ST_UNIVERSAL_CHARSTRING) FATAL_ERROR("SubType::add_ttcn_single()");
2318 UniversalCharstringSubtypeTreeElement* ucst_elem = new UniversalCharstringSubtypeTreeElement(StringValueConstraint<ustring>(v->get_val_ustr()));
2319 if (universal_charstring_st==NULL) universal_charstring_st = ucst_elem;
2320 else universal_charstring_st = new UniversalCharstringSubtypeTreeElement(UniversalCharstringSubtypeTreeElement::ET_UNION, universal_charstring_st, ucst_elem);
2321 } break;
2322 case Value::V_ENUM:
2323 case Value::V_NULL: // FIXME: should go to ST_NULL
2324 if (subtype!=ST_ENUM) FATAL_ERROR("SubType::add_ttcn_single()");
2325 add_ttcn_value(v);
2326 break;
2327 case Value::V_CHOICE:
2328 if (subtype!=ST_UNION) FATAL_ERROR("SubType::add_ttcn_single()");
2329 add_ttcn_value(v);
2330 break;
2331 case Value::V_SEQ:
2332 if (subtype!=ST_RECORD) FATAL_ERROR("SubType::add_ttcn_single()");
2333 add_ttcn_value(v);
2334 break;
2335 case Value::V_SET:
2336 if (subtype!=ST_SET) FATAL_ERROR("SubType::add_ttcn_single()");
2337 add_ttcn_value(v);
2338 break;
2339 case Value::V_FUNCTION:
2340 if (subtype!=ST_FUNCTION) FATAL_ERROR("SubType::add_ttcn_single()");
2341 add_ttcn_value(v);
2342 break;
2343 case Value::V_ALTSTEP:
2344 if (subtype!=ST_ALTSTEP) FATAL_ERROR("SubType::add_ttcn_single()");
2345 add_ttcn_value(v);
2346 break;
2347 case Value::V_TESTCASE:
2348 if (subtype!=ST_TESTCASE) FATAL_ERROR("SubType::add_ttcn_single()");
2349 add_ttcn_value(v);
2350 break;
2351 case Value::V_SEQOF:
2352 if (subtype!=ST_RECORDOF) FATAL_ERROR("SubType::add_ttcn_single()");
2353 add_ttcn_recof(v);
2354 break;
2355 case Value::V_SETOF:
2356 if (subtype!=ST_SETOF) FATAL_ERROR("SubType::add_ttcn_single()");
2357 add_ttcn_recof(v);
2358 break;
2359 case Value::V_ERROR:
2360 return false;
2361 default:
2362 return false;
2363 }
2364 return true;
2365}
2366
2367bool SubType::add_ttcn_range(Value *min, bool min_exclusive,
2368 Value *max, bool max_exclusive, size_t restriction_index, bool has_other)
2369{
2370 switch (subtype) {
2371 case ST_INTEGER:
2372 case ST_FLOAT:
2373 case ST_CHARSTRING:
2374 case ST_UNIVERSAL_CHARSTRING:
2375 break;
2376 default:
2377 my_owner->error("Range subtyping is not allowed for type `%s'",
2378 my_owner->get_typename().c_str());
2379 return false;
2380 }
2381
2382 Value *vmin,*vmax;
2383 if (min==NULL) vmin=NULL;
2384 else {
2385 min->set_my_scope(my_owner->get_my_scope());
2386 min->set_fullname(my_owner->get_fullname()+".<range_restriction_"+Int2string(restriction_index)+"_lower>");
2387 my_owner->chk_this_value_ref(min);
2388 my_owner->chk_this_value(min, 0, Type::EXPECTED_CONSTANT,
2389 INCOMPLETE_NOT_ALLOWED, OMIT_NOT_ALLOWED, NO_SUB_CHK);
2390 vmin=min->get_value_refd_last();
2391 }
2392 if (max==NULL) vmax=NULL;
2393 else {
2394 max->set_my_scope(my_owner->get_my_scope());
2395 max->set_fullname(my_owner->get_fullname()+".<range_restriction_"+Int2string(restriction_index)+"_upper>");
2396 my_owner->chk_this_value_ref(max);
2397 my_owner->chk_this_value(max, 0, Type::EXPECTED_CONSTANT,
2398 INCOMPLETE_NOT_ALLOWED, OMIT_NOT_ALLOWED, NO_SUB_CHK);
2399 vmax=max->get_value_refd_last();
2400 }
2401
2402 if ( (vmin!=NULL) && (vmax!=NULL) && (vmin->get_valuetype()!=vmax->get_valuetype()) ) return false;
2403
2404 switch (subtype) {
2405 case ST_INTEGER: {
2406 if (((vmin!=NULL) && (vmin->get_valuetype()!=Value::V_INT)) ||
2407 ((vmax!=NULL) && (vmax->get_valuetype()!=Value::V_INT))) return false;
2408 int_limit_t min_limit = (vmin!=NULL) ? int_limit_t(*(vmin->get_val_Int())) : int_limit_t::minimum;
2409 if (min_exclusive) {
2410 if (min_limit==int_limit_t::minimum) {
2411 my_owner->error("invalid lower boundary, -infinity cannot be excluded from an integer subtype range");
2412 return false;
2413 } else {
2414 if (min_limit==int_limit_t::maximum) {
2415 my_owner->error("!infinity is not a valid lower boundary");
2416 return false;
2417 }
2418 min_limit = min_limit.next();
2419 }
2420 }
2421 int_limit_t max_limit = (vmax!=NULL) ? int_limit_t(*(vmax->get_val_Int())) : int_limit_t::maximum;
2422 if (max_exclusive) {
2423 if (max_limit==int_limit_t::maximum) {
2424 my_owner->error("invalid upper boundary, infinity cannot be excluded from an integer subtype range");
2425 return false;
2426 } else {
2427 if (max_limit==int_limit_t::minimum) {
2428 my_owner->error("!-infinity is not a valid upper boundary");
2429 return false;
2430 }
2431 max_limit = max_limit.previous();
2432 }
2433 }
2434 if (max_limit<min_limit) {
2435 my_owner->error("lower boundary is bigger than upper boundary in integer subtype range");
2436 return false;
2437 }
2438 if (integer_st==NULL) integer_st = new IntegerRangeListConstraint(min_limit, max_limit);
2439 else *integer_st = *integer_st + IntegerRangeListConstraint(min_limit, max_limit);
2440 } break;
2441 case ST_FLOAT: {
2442 if (((vmin!=NULL) && (vmin->get_valuetype()!=Value::V_REAL)) ||
2443 ((vmax!=NULL) && (vmax->get_valuetype()!=Value::V_REAL))) return false;
2444 if ((vmin!=NULL) && (vmin->get_val_Real()!=vmin->get_val_Real())) {
2445 my_owner->error("lower boundary cannot be not_a_number in float subtype range");
2446 return false;
2447 }
2448 if ((vmax!=NULL) && (vmax->get_val_Real()!=vmax->get_val_Real())) {
2449 my_owner->error("upper boundary cannot be not_a_number in float subtype range");
2450 return false;
2451 }
2452 real_limit_t min_limit = (vmin!=NULL) ? real_limit_t(vmin->get_val_Real()) : real_limit_t::minimum;
2453 if (min_exclusive) {
2454 if (min_limit==real_limit_t::maximum) {
2455 my_owner->error("!infinity is not a valid lower boundary");
2456 return false;
2457 }
2458 min_limit = min_limit.next();
2459 }
2460 real_limit_t max_limit = (vmax!=NULL) ? real_limit_t(vmax->get_val_Real()) : real_limit_t::maximum;
2461 if (max_exclusive) {
2462 if (max_limit==real_limit_t::minimum) {
2463 my_owner->error("!-infinity is not a valid upper boundary");
2464 return false;
2465 }
2466 max_limit = max_limit.previous();
2467 }
2468 if (max_limit<min_limit) {
2469 my_owner->error("lower boundary is bigger than upper boundary in float subtype range");
2470 return false;
2471 }
2472 if (float_st==NULL) float_st = new RealRangeListConstraint(min_limit, max_limit);
2473 else *float_st = *float_st + RealRangeListConstraint(min_limit, max_limit);
2474 } break;
2475 case ST_CHARSTRING: {
2476 if (((vmin!=NULL) && (vmin->get_valuetype()!=Value::V_CSTR)) ||
2477 ((vmax!=NULL) && (vmax->get_valuetype()!=Value::V_CSTR))) return false;
2478 if ((vmin==NULL)&&(vmax==NULL)) {
2479 my_owner->error("a range subtype of a charstring cannot be (-infinity..infinity)");
2480 return false;
2481 }
2482 if (vmin==NULL) {
2483 my_owner->error("lower boundary of a charstring subtype range cannot be -infinity");
2484 return false;
2485 }
2486 if (vmax==NULL) {
2487 my_owner->error("upper boundary of a charstring subtype range cannot be infinity");
2488 return false;
2489 }
2490 if (vmin->get_val_str().size()!=1) {
2491 min->error("lower boundary of charstring subtype range must be a single element string");
2492 return false;
2493 }
2494 if (vmax->get_val_str().size()!=1) {
2495 max->error("upper boundary of charstring subtype range must be a single element string");
2496 return false;
2497 }
2498 if (!char_limit_t::is_valid_value(*vmin->get_val_str().c_str())) {
2499 min->error("lower boundary of charstring subtype range is an invalid char");
2500 return false;
2501 }
2502 if (!char_limit_t::is_valid_value(*vmax->get_val_str().c_str())) {
2503 max->error("upper boundary of charstring subtype range is an invalid char");
2504 return false;
2505 }
2506 char_limit_t min_limit(*vmin->get_val_str().c_str()), max_limit(*vmax->get_val_str().c_str());
2507 if (min_exclusive) {
2508 if (min_limit==char_limit_t::maximum) {
2509 min->error("exclusive lower boundary is not a legal charstring character");
2510 return false;
2511 }
2512 min_limit = min_limit.next();
2513 }
2514 if (max_exclusive) {
2515 if (max_limit==char_limit_t::minimum) {
2516 max->error("exclusive upper boundary is not a legal charstring character");
2517 return false;
2518 }
2519 max_limit = max_limit.previous();
2520 }
2521 if (max_limit<min_limit) {
2522 my_owner->error("lower boundary is bigger than upper boundary in charstring subtype range");
2523 return false;
2524 }
2525 if (charstring_st==NULL) charstring_st = new CharstringSubtypeTreeElement(CharRangeListConstraint(min_limit,max_limit), false);
2526 else {
2527 if (!has_other) { // union in char context can be done only with range constraints
2528 charstring_st->set_char_context(true);
2529 charstring_st = new CharstringSubtypeTreeElement(CharstringSubtypeTreeElement::ET_UNION,
2530 charstring_st,
2531 new CharstringSubtypeTreeElement(CharRangeListConstraint(min_limit,max_limit), true));
2532 charstring_st->set_char_context(false);
2533 } else {
2534 // ignore it, error reported elsewhere
2535 return false;
2536 }
2537 }
2538 } break;
2539 case ST_UNIVERSAL_CHARSTRING: {
2540 if (((vmin!=NULL) && (vmin->get_valuetype()!=Value::V_USTR)) ||
2541 ((vmax!=NULL) && (vmax->get_valuetype()!=Value::V_USTR))) return false;
2542 if ((vmin==NULL)&&(vmax==NULL)) {
2543 my_owner->error("a range subtype of a universal charstring cannot be (-infinity..infinity)");
2544 return false;
2545 }
2546 if (vmin==NULL) {
2547 my_owner->error("lower boundary of a universal charstring subtype range cannot be -infinity");
2548 return false;
2549 }
2550 if (vmax==NULL) {
2551 my_owner->error("upper boundary of a universal charstring subtype range cannot be infinity");
2552 return false;
2553 }
2554 if (vmin->get_val_ustr().size()!=1) {
2555 min->error("lower boundary of universal charstring subtype range must be a single element string");
2556 return false;
2557 }
2558 if (vmax->get_val_ustr().size()!=1) {
2559 max->error("upper boundary of universal charstring subtype range must be a single element string");
2560 return false;
2561 }
2562 if (!universal_char_limit_t::is_valid_value(*vmin->get_val_ustr().u_str())) {
2563 min->error("lower boundary of universal charstring subtype range is an invalid char");
2564 return false;
2565 }
2566 if (!universal_char_limit_t::is_valid_value(*vmax->get_val_ustr().u_str())) {
2567 max->error("upper boundary of universal charstring subtype range is an invalid char");
2568 return false;
2569 }
2570 universal_char_limit_t min_limit(*vmin->get_val_ustr().u_str()), max_limit(*vmax->get_val_ustr().u_str());
2571 if (min_exclusive) {
2572 if (min_limit==universal_char_limit_t::maximum) {
2573 min->error("exclusive lower boundary is not a legal universal charstring character");
2574 return false;
2575 }
2576 min_limit = min_limit.next();
2577 }
2578 if (max_exclusive) {
2579 if (max_limit==universal_char_limit_t::minimum) {
2580 max->error("exclusive upper boundary is not a legal universal charstring character");
2581 return false;
2582 }
2583 max_limit = max_limit.previous();
2584 }
2585 if (max_limit<min_limit) {
2586 my_owner->error("lower boundary is bigger than upper boundary in universal charstring subtype range");
2587 return false;
2588 }
2589
2590 if (universal_charstring_st==NULL) universal_charstring_st = new UniversalCharstringSubtypeTreeElement(UniversalCharRangeListConstraint(min_limit,max_limit), false);
2591 else {
2592 if (!has_other) { // union in char context can be done only with range constraints
2593 universal_charstring_st->set_char_context(true);
2594 universal_charstring_st = new UniversalCharstringSubtypeTreeElement(UniversalCharstringSubtypeTreeElement::ET_UNION,
2595 universal_charstring_st,
2596 new UniversalCharstringSubtypeTreeElement(UniversalCharRangeListConstraint(min_limit,max_limit), true));
2597 universal_charstring_st->set_char_context(false);
2598 } else {
2599 // ignore it, error reported elsewhere
2600 return false;
2601 }
2602 }
2603 } break;
2604 default:
2605 FATAL_ERROR("SubType::add_ttcn_range()");
2606 }
2607 return true;
2608}
2609
2610bool SubType::set_ttcn_length(const size_limit_t& min, const size_limit_t& max)
2611{
2612 switch (subtype) {
2613 case ST_BITSTRING: {
2614 if (bitstring_st==NULL) bitstring_st = new BitstringConstraint(min,max);
2615 else *bitstring_st = *bitstring_st * BitstringConstraint(min,max);
2616 } break;
2617 case ST_HEXSTRING: {
2618 if (hexstring_st==NULL) hexstring_st = new HexstringConstraint(min,max);
2619 else *hexstring_st = *hexstring_st * HexstringConstraint(min,max);
2620 } break;
2621 case ST_OCTETSTRING: {
2622 if (octetstring_st==NULL) octetstring_st = new OctetstringConstraint(min,max);
2623 else *octetstring_st = *octetstring_st * OctetstringConstraint(min,max);
2624 } break;
2625 case ST_CHARSTRING: {
2626 CharstringSubtypeTreeElement* cst_elem = new CharstringSubtypeTreeElement(SizeRangeListConstraint(min,max));
2627 if (charstring_st==NULL) {
2628 charstring_st = cst_elem;
2629 } else {
2630 charstring_st = new CharstringSubtypeTreeElement(CharstringSubtypeTreeElement::ET_INTERSECTION, charstring_st, cst_elem);
2631 }
2632 } break;
2633 case ST_UNIVERSAL_CHARSTRING: {
2634 UniversalCharstringSubtypeTreeElement* ucst_elem = new UniversalCharstringSubtypeTreeElement(SizeRangeListConstraint(min,max));
2635 if (universal_charstring_st==NULL) {
2636 universal_charstring_st = ucst_elem;
2637 } else {
2638 universal_charstring_st = new UniversalCharstringSubtypeTreeElement(UniversalCharstringSubtypeTreeElement::ET_INTERSECTION, universal_charstring_st, ucst_elem);
2639 }
2640 } break;
2641 case ST_RECORDOF:
2642 case ST_SETOF: {
2643 if (recof_st==NULL) recof_st = new RecofConstraint(min,max);
2644 else *recof_st = *recof_st * RecofConstraint(min,max);
2645 } break;
2646 default:
2647 my_owner->error("Length subtyping is not allowed for type `%s'",
2648 my_owner->get_typename().c_str());
2649 return false;
2650 }
2651 if (length_restriction==NULL) length_restriction = new SizeRangeListConstraint(min,max);
2652 else *length_restriction = *length_restriction * SizeRangeListConstraint(min,max);
2653 return true;
2654}
2655
2656void SubType::chk_boundary_valid(Value* boundary, Int max_value, const char* boundary_name)
2657{
2658 const int_val_t *int_val = boundary->get_val_Int();
2659 if (*int_val > int_val_t(max_value)) {
2660 boundary->error("The %s should be less than `%s' instead of `%s'",
2661 boundary_name,
2662 int_val_t(max_value).t_str().c_str(),
2663 int_val->t_str().c_str());
2664 boundary->set_valuetype(Value::V_ERROR);
2665 }
2666}
2667
2668bool SubType::add_ttcn_length(Ttcn::LengthRestriction *lr, size_t restriction_index)
2669{
2670 string s;
2671 lr->append_stringRepr(s);
2672 Value *lower=NULL,*upper=NULL;
2673 lr->set_my_scope(my_owner->get_my_scope());
2674 lr->set_fullname(my_owner->get_fullname()+".<length_restriction_"+Int2string(restriction_index)+">");
2675 lr->chk(Type::EXPECTED_CONSTANT);
2676 lower = lr->get_is_range() ? lr->get_lower_value() : lr->get_single_value();
2677 if (!lower->get_my_scope()) FATAL_ERROR("no scope");
2678 if (lower->get_valuetype() != Value::V_INT) return false;
2679 if (lr->get_is_range()) {
2680 upper = lr->get_upper_value();
2681 if (upper) {//HAS_UPPER
2682 if (upper->get_valuetype()!=Value::V_INT) return false;
2683 if (!upper->get_my_scope()) upper->set_my_scope(my_owner->get_my_scope());
2684 chk_boundary_valid(upper, INT_MAX, "upper boundary");
2685 if (upper->get_valuetype()!=Value::V_INT) return false;
2686 return set_ttcn_length(size_limit_t((size_t)lower->get_val_Int()->get_val()),
2687 size_limit_t((size_t)upper->get_val_Int()->get_val()));
2688 } else {//INFINITY:
2689 chk_boundary_valid(lower, INT_MAX, "lower boundary");
2690 if (lower->get_valuetype()!=Value::V_INT) return false;
2691 return set_ttcn_length(size_limit_t((size_t)lower->get_val_Int()->get_val()),
2692 size_limit_t(size_limit_t::INFINITE_SIZE));
2693 }
2694 }
2695 else {//SINGLE:
2696 chk_boundary_valid(lower, INT_MAX, "length restriction value");
2697 if (lower->get_valuetype()!=Value::V_INT) return false;
2698 return set_ttcn_length(size_limit_t((size_t)lower->get_val_Int()->get_val()),
2699 size_limit_t((size_t)lower->get_val_Int()->get_val()));
2700 }
2701}
2702
2703bool SubType::add_ttcn_pattern(Ttcn::PatternString* pattern, size_t restriction_index)
2704{
2705 pattern->set_my_scope(my_owner->get_my_scope());
2706 pattern->set_fullname(my_owner->get_fullname()+".<pattern_restriction_"+Int2string(restriction_index) + ">");
2707 switch (subtype) {
2708 case ST_CHARSTRING: {
2709 Error_Context cntxt(my_owner, "In character string pattern");
2710 pattern->chk_refs(Type::EXPECTED_CONSTANT);
2711 pattern->join_strings();
2712 if (!pattern->has_refs()) { // if chk_refs didn't remove all references then ignore
2713 pattern->chk_pattern();
2714 CharstringSubtypeTreeElement* cst_elem = new CharstringSubtypeTreeElement(StringPatternConstraint(pattern));
2715 if (charstring_st==NULL) {
2716 charstring_st = cst_elem;
2717 } else {
2718 charstring_st = new CharstringSubtypeTreeElement(CharstringSubtypeTreeElement::ET_INTERSECTION, charstring_st, cst_elem);
2719 }
2720 }
2721 } break;
2722 case ST_UNIVERSAL_CHARSTRING: {
2723 Error_Context cntxt(my_owner, "In universal string pattern");
2724 pattern->set_pattern_type(Ttcn::PatternString::USTR_PATTERN);
2725 pattern->chk_refs(Type::EXPECTED_CONSTANT);
2726 pattern->join_strings();
2727 if (!pattern->has_refs()) { // if chk_refs didn't remove all references then ignore
2728 pattern->chk_pattern();
2729 UniversalCharstringSubtypeTreeElement* ucst_elem = new UniversalCharstringSubtypeTreeElement(StringPatternConstraint(pattern));
2730 if (universal_charstring_st==NULL) {
2731 universal_charstring_st = ucst_elem;
2732 } else {
2733 universal_charstring_st = new UniversalCharstringSubtypeTreeElement(UniversalCharstringSubtypeTreeElement::ET_INTERSECTION, universal_charstring_st, ucst_elem);
2734 }
2735 }
2736 } break;
2737 default:
2738 my_owner->error("Pattern subtyping of type `%s' is not allowed", my_owner->get_typename().c_str());
2739 return false;
2740 }
2741 return true;
2742}
2743
2744void SubType::print_full_warning() const
2745{
2746 my_owner->warning("The subtype of type `%s' is a full set, "
2747 "it does not constrain the root type.", my_owner->get_typename().c_str());
2748}
2749
2750void SubType::chk()
2751{
2752 if ((checked!=STC_NO) || (subtype==ST_ERROR)) FATAL_ERROR("SubType::chk()");
2753 checked = STC_CHECKING;
2754
2755 // check for circular subtype reference
2756 if (parent_subtype && !add_parent_subtype(parent_subtype)) {
2757 set_to_error();
2758 checked = STC_YES;
2759 return;
2760 }
2761
2762 if (parsed) { // has TTCN-3 subtype constraint
2763 size_t added_count = 0;
2764 bool has_single = false, has_range = false,
2765 has_length = false, has_pattern = false;
2766 for (size_t i = 0; i < parsed->size(); i++) {
2767 bool added = false;
2768 SubTypeParse *parse = (*parsed)[i];
2769 switch (parse->get_selection()) {
2770 case SubTypeParse::STP_SINGLE:
2771 has_single = true;
2772 added = add_ttcn_single(parse->Single(),i);
2773 break;
2774 case SubTypeParse::STP_RANGE:
2775 has_range = true;
2776 added = add_ttcn_range(parse->Min(), parse->MinExclusive(),
2777 parse->Max(), parse->MaxExclusive(), i,
2778 has_single || has_length || has_pattern);
2779 break;
2780 case SubTypeParse::STP_LENGTH:
2781 has_length = true;
2782 added = add_ttcn_length(parse->Length(),i);
2783 break;
2784 case SubTypeParse::STP_PATTERN:
2785 has_pattern = true;
2786 added = add_ttcn_pattern(parse->Pattern(),i);
2787 break;
2788 default:
2789 FATAL_ERROR("SubType::chk(): invalid SubTypeParse selection");
2790 } // switch
2791 if (added) added_count++;
2792 }//for
2793 switch (subtype) {
2794 case ST_CHARSTRING:
2795 case ST_UNIVERSAL_CHARSTRING:
2796 if (has_single && has_range) {
2797 my_owner->error(
2798 "Mixing of value list and range subtyping is not allowed for type `%s'",
2799 my_owner->get_typename().c_str());
2800 set_to_error();
2801 checked = STC_YES;
2802 return;
2803 }
2804 break;
2805 default:
2806 // in other cases mixing of different restrictions (which are legal for
2807 // this type) is properly regulated by the TTCN-3 BNF itself
2808 break;
2809 }
2810 if (added_count<parsed->size()) {
2811 set_to_error();
2812 checked = STC_YES;
2813 return;
2814 }
2815 if (subtype==ST_ERROR) { checked = STC_YES; return; }
2816
2817 if (parent_subtype) {
2818 if (is_subset(parent_subtype->get_root())==TFALSE) {
2819 my_owner->error("The subtype restriction is not a subset of the restriction on the parent type. "
2820 "Subtype %s is not subset of subtype %s", to_string().c_str(), parent_subtype->get_root()->to_string().c_str());
2821 set_to_error();
2822 checked = STC_YES;
2823 return;
2824 }
2825 intersection(parent_subtype->get_root());
2826 }
2827 } else if (asn_constraints) { // has ASN.1 subtype constraint
2828 SubtypeConstraint* asn_parent_subtype = NULL;
2829 if (parent_subtype) {
2830 // the type constraint of the ASN.1 type is already in the parent_subtype,
2831 // don't add it multiple times
2832 asn_parent_subtype = parent_subtype->get_root();
2833 } else {
2834 asn_parent_subtype = get_asn_type_constraint(my_owner);
2835 }
2836 asn_constraints->chk(asn_parent_subtype);
2837 root = asn_constraints->get_subtype();
2838 extendable = asn_constraints->is_extendable();
2839 extension = asn_constraints->get_extension();
2840 // the TTCN-3 subtype will be the union of the root and extension parts
2841 // the ETSI ES 201 873-7 V4.1.2 (2009-07) document says to "ignore any extension markers"
2842 // but titan now works this way :)
2843 if (root) copy(root);
2844 if (extension) union_(extension);
2845 } else { // no constraints on this type -> this is an alias type, just copy the subtype from the other
2846 if (parent_subtype) {
2847 root = parent_subtype->root;
2848 extendable = parent_subtype->extendable;
2849 extension = parent_subtype->extension;
2850 copy(parent_subtype);
2851 } else {
2852 SubtypeConstraint* asn_parent_subtype = get_asn_type_constraint(my_owner);
2853 if (asn_parent_subtype) copy(asn_parent_subtype);
2854 }
2855 }
2856
2857 // check if subtype is valid: it must not be an empty set (is_empty==TTRUE)
2858 // issue warning if subtype is given but is full set (is_full==TTRUE)
2859 // ignore cases of TUNKNOWN when compiler can't figure out if the aggregate
2860 // set is empty or full
2861 switch (subtype) {
2862 case ST_INTEGER:
2863 if (integer_st!=NULL) {
2864 if (integer_st->is_empty()==TTRUE) goto empty_error;
2865 if (integer_st->is_full()==TTRUE) {
2866 print_full_warning();
2867 delete integer_st;
2868 integer_st = NULL;
2869 }
2870 }
2871 break;
2872 case ST_FLOAT:
2873 if (float_st!=NULL) {
2874 if (float_st->is_empty()==TTRUE) goto empty_error;
2875 if (float_st->is_full()==TTRUE) {
2876 print_full_warning();
2877 delete float_st;
2878 float_st = NULL;
2879 }
2880 }
2881 break;
2882 case ST_BOOLEAN:
2883 if (boolean_st!=NULL) {
2884 if (boolean_st->is_empty()==TTRUE) goto empty_error;
2885 if (boolean_st->is_full()==TTRUE) {
2886 print_full_warning();
2887 delete boolean_st;
2888 boolean_st = NULL;
2889 }
2890 }
2891 break;
2892 case ST_VERDICTTYPE:
2893 if (verdict_st!=NULL) {
2894 if (verdict_st->is_empty()==TTRUE) goto empty_error;
2895 if (verdict_st->is_full()==TTRUE) {
2896 print_full_warning();
2897 delete verdict_st;
2898 verdict_st = NULL;
2899 }
2900 }
2901 break;
2902 case ST_BITSTRING:
2903 if (bitstring_st!=NULL) {
2904 if (bitstring_st->is_empty()==TTRUE) goto empty_error;
2905 if (bitstring_st->is_full()==TTRUE) {
2906 print_full_warning();
2907 delete bitstring_st;
2908 bitstring_st = NULL;
2909 }
2910 }
2911 break;
2912 case ST_HEXSTRING:
2913 if (hexstring_st!=NULL) {
2914 if (hexstring_st->is_empty()==TTRUE) goto empty_error;
2915 if (hexstring_st->is_full()==TTRUE) {
2916 print_full_warning();
2917 delete hexstring_st;
2918 hexstring_st = NULL;
2919 }
2920 }
2921 break;
2922 case ST_OCTETSTRING:
2923 if (octetstring_st!=NULL) {
2924 if (octetstring_st->is_empty()==TTRUE) goto empty_error;
2925 if (octetstring_st->is_full()==TTRUE) {
2926 print_full_warning();
2927 delete octetstring_st;
2928 octetstring_st = NULL;
2929 }
2930 }
2931 break;
2932 case ST_CHARSTRING:
2933 if (charstring_st!=NULL) {
2934 if (charstring_st->is_empty()==TTRUE) goto empty_error;
2935 if (charstring_st->is_full()==TTRUE) {
2936 print_full_warning();
2937 delete charstring_st;
2938 charstring_st = NULL;
2939 }
2940 }
2941 break;
2942 case ST_UNIVERSAL_CHARSTRING:
2943 if (universal_charstring_st!=NULL) {
2944 if (universal_charstring_st->is_empty()==TTRUE) goto empty_error;
2945 if (universal_charstring_st->is_full()==TTRUE) {
2946 print_full_warning();
2947 delete universal_charstring_st;
2948 universal_charstring_st = NULL;
2949 }
2950 }
2951 break;
2952 case ST_OBJID:
2953 case ST_RECORD:
2954 case ST_SET:
2955 case ST_ENUM:
2956 case ST_UNION:
2957 case ST_FUNCTION:
2958 case ST_ALTSTEP:
2959 case ST_TESTCASE:
2960 if (value_st!=NULL) {
2961 if (value_st->is_empty()==TTRUE) goto empty_error;
2962 if (value_st->is_full()==TTRUE) {
2963 print_full_warning();
2964 delete value_st;
2965 value_st = NULL;
2966 }
2967 }
2968 break;
2969 case ST_RECORDOF:
2970 case ST_SETOF:
2971 if (recof_st!=NULL) {
2972 if (recof_st->is_empty()==TTRUE) goto empty_error;
2973 if (recof_st->is_full()==TTRUE) {
2974 print_full_warning();
2975 delete recof_st;
2976 recof_st = NULL;
2977 }
2978 }
2979 break;
2980 default:
2981 FATAL_ERROR("SubType::chk()");
2982 }
2983 if ((length_restriction!=NULL) && (length_restriction->is_full()==TTRUE)) {
2984 delete length_restriction;
2985 length_restriction = NULL;
2986 }
2987 checked = STC_YES;
2988 return;
2989
2990empty_error:
2991 my_owner->error("The subtype is an empty set");
2992 set_to_error();
2993 checked = STC_YES;
2994 return;
2995}
2996
2997void SubType::dump(unsigned level) const
2998{
2999 string str = to_string();
3000 if (str.size()>0) DEBUG(level, "restriction(s): %s", str.c_str());
3001}
3002
3003Int SubType::get_length_restriction() const
3004{
3005 if (checked!=STC_YES) FATAL_ERROR("SubType::get_length_restriction()");
3006 if (parsed==NULL) return -1; // only own length restriction counts
3007 if (length_restriction==NULL) return -1;
3008 if (length_restriction->is_empty()) return -1;
3009 return ( (length_restriction->get_minimal()==length_restriction->get_maximal()) ?
3010 (Int)(length_restriction->get_minimal().get_size()) :
3011 -1 );
3012}
3013
3014bool SubType::zero_length_allowed() const
3015{
3016 if (checked!=STC_YES) FATAL_ERROR("SubType::zero_length_allowed()");
3017 if (parsed==NULL) return true; // only own length restriction counts
3018 if (length_restriction==NULL) return true;
3019 return length_restriction->is_element(size_limit_t(0));
3020}
3021
3022string SubType::to_string() const
3023{
3024 if (root) {
3025 string ret_val(root->to_string());
3026 if (extendable) ret_val += ", ...";
3027 if (extension) {
3028 ret_val += ", ";
3029 ret_val += extension->to_string();
3030 }
3031 return ret_val;
3032 }
3033 return SubtypeConstraint::to_string();
3034}
3035
3036////////////////////////////////////////////////////////////////////////////////
3037
3038void SubType::generate_code(output_struct &)
3039{
3040 if (checked!=STC_YES) FATAL_ERROR("SubType::generate_code()");
3041}
3042
3043} // namespace Common
Titan Core - Deliverables
This page took 0.147009 seconds and 5 git commands to generate.