compiler2/subtype.cc

   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
  23 namespace Common {
  24
  25 /**************************
  26 class SubTypeParse
  27 **************************/
  28
  29 SubTypeParse::SubTypeParse(Value *p_single)
  30 : selection(STP_SINGLE)
  31 {
  32   if (!p_single) FATAL_ERROR("SubTypeParse::SubTypeParse()");
  33   single = p_single;
  34 }
  35
  36 SubTypeParse::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
  45 SubTypeParse::SubTypeParse(Ttcn::LengthRestriction *p_length)
  46 : selection(STP_LENGTH)
  47 {
  48   if (!p_length) FATAL_ERROR("SubTypeParse::SubTypeParse()");
  49   length = p_length;
  50 }
  51
  52 SubTypeParse::SubTypeParse(Ttcn::PatternString *p_pattern)
  53 : selection(STP_PATTERN)
  54 {
  55   if (!p_pattern) FATAL_ERROR("SubTypeParse::SubTypeParse()");
  56   pattern = p_pattern;
  57 }
  58
  59 SubTypeParse::~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
  80 Value *SubTypeParse::Single() const
  81 {
  82   if (selection != STP_SINGLE) FATAL_ERROR("SubTypeParse::Single()");
  83   return single;
  84 }
  85
  86 Value *SubTypeParse::Min() const
  87 {
  88   if (selection != STP_RANGE) FATAL_ERROR("SubTypeParse::Min()");
  89   return range.min;
  90 }
  91
  92 bool SubTypeParse::MinExclusive() const
  93 {
  94   if (selection != STP_RANGE) FATAL_ERROR("SubTypeParse::MinExclusive()");
  95   return range.min_exclusive;
  96 }
  97
  98 Value *SubTypeParse::Max() const
  99 {
 100   if (selection != STP_RANGE) FATAL_ERROR("SubTypeParse::Max()");
 101   return range.max;
 102 }
 103
 104 bool SubTypeParse::MaxExclusive() const
 105 {
 106   if (selection != STP_RANGE) FATAL_ERROR("SubTypeParse::MaxExclusive()");
 107   return range.max_exclusive;
 108 }
 109
 110 Ttcn::LengthRestriction *SubTypeParse::Length() const
 111 {
 112   if (selection != STP_LENGTH) FATAL_ERROR("SubTypeParse::Length()");
 113   return length;
 114 }
 115
 116 Ttcn::PatternString *SubTypeParse::Pattern() const
 117 {
 118   if (selection != STP_PATTERN) FATAL_ERROR("SubTypeParse::Pattern()");
 119   return pattern;
 120 }
 121
 122 /********************
 123 class SubtypeConstraint
 124 ********************/
 125
 126 SubtypeConstraint::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
 177 void 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
 241 struct 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
 249 AsnTypeConstraintSingleton::~AsnTypeConstraintSingleton()
 250 {
 251   delete printablestring_stc;
 252   delete numericstring_stc;
 253   delete bmpstring_stc;
 254 }
 255
 256 SubtypeConstraint* 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
 315 SubtypeConstraint* 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;
 397 invalid_value:
 398   delete stc;
 399   return NULL;
 400 }
 401
 402 SubtypeConstraint* 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;
 444 invalid_value:
 445   delete stc;
 446   return NULL;
 447 }
 448
 449 int_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
 547 SubtypeConstraint* 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
 862 SubtypeConstraint* 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
 905 SubtypeConstraint* 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
 979 SubtypeConstraint* 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
1016 void 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
1070 string 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
1110 bool 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
1180 bool 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
1233 bool 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
1244 void SubtypeConstraint::except(const SubtypeConstraint* other)
1245 {
1246   if (other==NULL) FATAL_ERROR("SubtypeConstraint::except()");
1247   if (subtype!=other->subtype) FATAL_ERROR("SubtypeConstraint::except()");
1248   switch (subtype) {
1249   case ST_INTEGER:
1250     if (other->integer_st==NULL) {
1251       if (integer_st==NULL) {
1252         integer_st = new IntegerRangeListConstraint();
1253       } else {
1254         *integer_st = IntegerRangeListConstraint();
1255       }
1256     } else {
1257       if (integer_st==NULL) {
1258         integer_st = new IntegerRangeListConstraint(~*(other->integer_st));
1259       } else {
1260         *integer_st = *integer_st - *(other->integer_st);
1261       }
1262     }
1263     break;
1264   case ST_FLOAT:
1265     if (other->float_st==NULL) {
1266       if (float_st==NULL) {
1267         float_st = new RealRangeListConstraint();
1268       } else {
1269         *float_st = RealRangeListConstraint();
1270       }
1271     } else {
1272       if (float_st==NULL) {
1273         float_st = new RealRangeListConstraint(~*(other->float_st));
1274       } else {
1275         *float_st = *float_st - *(other->float_st);
1276       }
1277     }
1278     break;
1279   case ST_BOOLEAN:
1280     if (other->boolean_st==NULL) {
1281       if (boolean_st==NULL) {
1282         boolean_st = new BooleanListConstraint();
1283       } else {
1284         *boolean_st = BooleanListConstraint();
1285       }
1286     } else {
1287       if (boolean_st==NULL) {
1288         boolean_st = new BooleanListConstraint(~*(other->boolean_st));
1289       } else {
1290         *boolean_st = *boolean_st - *(other->boolean_st);
1291       }
1292     }
1293     break;
1294   case ST_VERDICTTYPE:
1295     if (other->verdict_st==NULL) {
1296       if (verdict_st==NULL) {
1297         verdict_st = new VerdicttypeListConstraint();
1298       } else {
1299         *verdict_st = VerdicttypeListConstraint();
1300       }
1301     } else {
1302       if (verdict_st==NULL) {
1303         verdict_st = new VerdicttypeListConstraint(~*(other->verdict_st));
1304       } else {
1305         *verdict_st = *verdict_st - *(other->verdict_st);
1306       }
1307     }
1308     break;
1309   case ST_BITSTRING:
1310     if (other->bitstring_st==NULL) {
1311       if (bitstring_st==NULL) {
1312         bitstring_st = new BitstringConstraint();
1313       } else {
1314         *bitstring_st = BitstringConstraint();
1315       }
1316     } else {
1317       if (bitstring_st==NULL) {
1318         bitstring_st = new BitstringConstraint(~*(other->bitstring_st));
1319       } else {
1320         *bitstring_st = *bitstring_st - *(other->bitstring_st);
1321       }
1322     }
1323     break;
1324   case ST_HEXSTRING:
1325     if (other->hexstring_st==NULL) {
1326       if (hexstring_st==NULL) {
1327         hexstring_st = new HexstringConstraint();
1328       } else {
1329         *hexstring_st = HexstringConstraint();
1330       }
1331     } else {
1332       if (hexstring_st==NULL) {
1333         hexstring_st = new HexstringConstraint(~*(other->hexstring_st));
1334       } else {
1335         *hexstring_st = *hexstring_st - *(other->hexstring_st);
1336       }
1337     }
1338     break;
1339   case ST_OCTETSTRING:
1340     if (other->octetstring_st==NULL) {
1341       if (octetstring_st==NULL) {
1342         octetstring_st = new OctetstringConstraint();
1343       } else {
1344         *octetstring_st = OctetstringConstraint();
1345       }
1346     } else {
1347       if (octetstring_st==NULL) {
1348         octetstring_st = new OctetstringConstraint(~*(other->octetstring_st));
1349       } else {
1350         *octetstring_st = *octetstring_st - *(other->octetstring_st);
1351       }
1352     }
1353     break;
1354   case ST_CHARSTRING:
1355     if (other->charstring_st==NULL) {
1356       if (charstring_st==NULL) {
1357         charstring_st = new CharstringSubtypeTreeElement();
1358       } else {
1359         *charstring_st = CharstringSubtypeTreeElement();
1360       }
1361     } else {
1362       if (charstring_st==NULL) {
1363         CharstringSubtypeTreeElement* call_st = new CharstringSubtypeTreeElement();
1364         call_st->set_all();
1365         charstring_st = new CharstringSubtypeTreeElement(CharstringSubtypeTreeElement::ET_EXCEPT,
1366           call_st, new CharstringSubtypeTreeElement(*(other->charstring_st)));
1367       } else {
1368         charstring_st = new CharstringSubtypeTreeElement(CharstringSubtypeTreeElement::ET_EXCEPT,
1369           charstring_st, new CharstringSubtypeTreeElement(*(other->charstring_st)));
1370       }
1371     }
1372     break;
1373   case ST_UNIVERSAL_CHARSTRING:
1374     if (other->universal_charstring_st==NULL) {
1375       if (universal_charstring_st==NULL) {
1376         universal_charstring_st = new UniversalCharstringSubtypeTreeElement();
1377       } else {
1378         *universal_charstring_st = UniversalCharstringSubtypeTreeElement();
1379       }
1380     } else {
1381       if (universal_charstring_st==NULL) {
1382         UniversalCharstringSubtypeTreeElement* ucall_st = new UniversalCharstringSubtypeTreeElement();
1383         ucall_st->set_all();
1384         universal_charstring_st = new UniversalCharstringSubtypeTreeElement(UniversalCharstringSubtypeTreeElement::ET_EXCEPT,
1385           ucall_st, new UniversalCharstringSubtypeTreeElement(*(other->universal_charstring_st)));
1386       } else {
1387         universal_charstring_st = new UniversalCharstringSubtypeTreeElement(UniversalCharstringSubtypeTreeElement::ET_EXCEPT,
1388           universal_charstring_st, new UniversalCharstringSubtypeTreeElement(*(other->universal_charstring_st)));
1389       }
1390     }
1391     break;
1392   case ST_OBJID:
1393   case ST_RECORD:
1394   case ST_SET:
1395   case ST_ENUM:
1396   case ST_UNION:
1397   case ST_FUNCTION:
1398   case ST_ALTSTEP:
1399   case ST_TESTCASE:
1400     if (other->value_st==NULL) {
1401       if (value_st==NULL) {
1402         value_st = new ValueListConstraint();
1403       } else {
1404         *value_st = ValueListConstraint();
1405       }
1406     } else {
1407       if (value_st==NULL) {
1408         value_st = new ValueListConstraint(~*(other->value_st));
1409       } else {
1410         *value_st = *value_st - *(other->value_st);
1411       }
1412     }
1413     break;
1414   case ST_RECORDOF:
1415   case ST_SETOF:
1416     if (other->recof_st==NULL) {
1417       if (recof_st==NULL) {
1418         recof_st = new RecofConstraint();
1419       } else {
1420         *recof_st = RecofConstraint();
1421       }
1422     } else {
1423       if (recof_st==NULL) {
1424         recof_st = new RecofConstraint(~*(other->recof_st));
1425       } else {
1426         *recof_st = *recof_st - *(other->recof_st);
1427       }
1428     }
1429     break;
1430   default:
1431     FATAL_ERROR("SubtypeConstraint::except()");
1432   }
1433   if (other->length_restriction==NULL) {
1434     if (length_restriction==NULL) {
1435       length_restriction = new SizeRangeListConstraint();
1436     } else {
1437       *length_restriction = SizeRangeListConstraint();
1438     }
1439   } else {
1440     if (length_restriction==NULL) {
1441       length_restriction = new SizeRangeListConstraint(~*(other->length_restriction));
1442     } else {
1443       *length_restriction = *length_restriction - *(other->length_restriction);
1444     }
1445   }
1446 }
1447
1448 void SubtypeConstraint::union_(const SubtypeConstraint* other)
1449 {
1450   if (other==NULL) FATAL_ERROR("SubtypeConstraint::union_()");
1451   if (subtype!=other->subtype) FATAL_ERROR("SubtypeConstraint::union_()");
1452   switch (subtype) {
1453   case ST_INTEGER:
1454     if (integer_st==NULL) break;
1455     if (other->integer_st==NULL) { delete integer_st; integer_st = NULL; break; }
1456     *integer_st = *integer_st + *(other->integer_st);
1457     break;
1458   case ST_FLOAT:
1459     if (float_st==NULL) break;
1460     if (other->float_st==NULL) { delete float_st; float_st = NULL; break; }
1461     *float_st = *float_st + *(other->float_st);
1462     break;
1463   case ST_BOOLEAN:
1464     if (boolean_st==NULL) break;
1465     if (other->boolean_st==NULL) { delete boolean_st; boolean_st = NULL; break; }
1466     *boolean_st = *boolean_st + *(other->boolean_st);
1467     break;
1468   case ST_VERDICTTYPE:
1469     if (verdict_st==NULL) break;
1470     if (other->verdict_st==NULL) { delete verdict_st; verdict_st = NULL; break; }
1471     *verdict_st = *verdict_st + *(other->verdict_st);
1472     break;
1473   case ST_BITSTRING:
1474     if (bitstring_st==NULL) break;
1475     if (other->bitstring_st==NULL) { delete bitstring_st; bitstring_st = NULL; break; }
1476     *bitstring_st = *bitstring_st + *(other->bitstring_st);
1477     break;
1478   case ST_HEXSTRING:
1479     if (hexstring_st==NULL) break;
1480     if (other->hexstring_st==NULL) { delete hexstring_st; hexstring_st = NULL; break; }
1481     *hexstring_st = *hexstring_st + *(other->hexstring_st);
1482     break;
1483   case ST_OCTETSTRING:
1484     if (octetstring_st==NULL) break;
1485     if (other->octetstring_st==NULL) { delete octetstring_st; octetstring_st = NULL; break; }
1486     *octetstring_st = *octetstring_st + *(other->octetstring_st);
1487     break;
1488   case ST_CHARSTRING:
1489     if (charstring_st==NULL) break;
1490     if (other->charstring_st==NULL) { delete charstring_st; charstring_st = NULL; break; }
1491     charstring_st = new CharstringSubtypeTreeElement(CharstringSubtypeTreeElement::ET_UNION,
1492       charstring_st, new CharstringSubtypeTreeElement(*(other->charstring_st)));
1493     break;
1494   case ST_UNIVERSAL_CHARSTRING:
1495     if (universal_charstring_st==NULL) break;
1496     if (other->universal_charstring_st==NULL) { delete universal_charstring_st; universal_charstring_st = NULL; break; }
1497     universal_charstring_st = new UniversalCharstringSubtypeTreeElement(UniversalCharstringSubtypeTreeElement::ET_UNION,
1498       universal_charstring_st, new UniversalCharstringSubtypeTreeElement(*(other->universal_charstring_st)));
1499     break;
1500   case ST_OBJID:
1501   case ST_RECORD:
1502   case ST_SET:
1503   case ST_ENUM:
1504   case ST_UNION:
1505   case ST_FUNCTION:
1506   case ST_ALTSTEP:
1507   case ST_TESTCASE:
1508     if (value_st==NULL) break;
1509     if (other->value_st==NULL) { delete value_st; value_st = NULL; break; }
1510     *value_st = *value_st + *(other->value_st);
1511     break;
1512   case ST_RECORDOF:
1513   case ST_SETOF:
1514     if (recof_st==NULL) break;
1515     if (other->recof_st==NULL) { delete recof_st; recof_st = NULL; break; }
1516     *recof_st = *recof_st + *(other->recof_st);
1517     break;
1518   default:
1519     FATAL_ERROR("SubtypeConstraint::union_()");
1520   }
1521   if (length_restriction!=NULL) {
1522     if (other->length_restriction==NULL) {
1523       delete length_restriction;
1524       length_restriction = NULL;
1525     } else {
1526       *length_restriction = *length_restriction + *(other->length_restriction);
1527     }
1528   }
1529 }
1530
1531 void SubtypeConstraint::intersection(const SubtypeConstraint* other)
1532 {
1533   if (other==NULL) FATAL_ERROR("SubtypeConstraint::intersection()");
1534   if (subtype!=other->subtype) FATAL_ERROR("SubtypeConstraint::intersection()");
1535   switch (subtype) {
1536   case ST_INTEGER:
1537     if (other->integer_st!=NULL) {
1538       if (integer_st==NULL) {
1539         integer_st = new IntegerRangeListConstraint(*(other->integer_st));
1540       } else {
1541         *integer_st = *integer_st * *(other->integer_st);
1542       }
1543     }
1544     break;
1545   case ST_FLOAT:
1546     if (other->float_st!=NULL) {
1547       if (float_st==NULL) {
1548         float_st = new RealRangeListConstraint(*(other->float_st));
1549       } else {
1550         *float_st = *float_st * *(other->float_st);
1551       }
1552     }
1553     break;
1554   case ST_BOOLEAN:
1555     if (other->boolean_st!=NULL) {
1556       if (boolean_st==NULL) {
1557         boolean_st = new BooleanListConstraint(*(other->boolean_st));
1558       } else {
1559         *boolean_st = *boolean_st * *(other->boolean_st);
1560       }
1561     }
1562     break;
1563   case ST_VERDICTTYPE:
1564     if (other->verdict_st!=NULL) {
1565       if (verdict_st==NULL) {
1566         verdict_st = new VerdicttypeListConstraint(*(other->verdict_st));
1567       } else {
1568         *verdict_st = *verdict_st * *(other->verdict_st);
1569       }
1570     }
1571     break;
1572   case ST_BITSTRING:
1573     if (other->bitstring_st!=NULL) {
1574       if (bitstring_st==NULL) {
1575         bitstring_st = new BitstringConstraint(*(other->bitstring_st));
1576       } else {
1577         *bitstring_st = *bitstring_st * *(other->bitstring_st);
1578       }
1579     }
1580     break;
1581   case ST_HEXSTRING:
1582     if (other->hexstring_st!=NULL) {
1583       if (hexstring_st==NULL) {
1584         hexstring_st = new HexstringConstraint(*(other->hexstring_st));
1585       } else {
1586         *hexstring_st = *hexstring_st * *(other->hexstring_st);
1587       }
1588     }
1589     break;
1590   case ST_OCTETSTRING:
1591     if (other->octetstring_st!=NULL) {
1592       if (octetstring_st==NULL) {
1593         octetstring_st = new OctetstringConstraint(*(other->octetstring_st));
1594       } else {
1595         *octetstring_st = *octetstring_st * *(other->octetstring_st);
1596       }
1597     }
1598     break;
1599   case ST_CHARSTRING:
1600     if (other->charstring_st!=NULL) {
1601       if (charstring_st==NULL) {
1602         charstring_st = new CharstringSubtypeTreeElement(*(other->charstring_st));
1603       } else {
1604         charstring_st = new CharstringSubtypeTreeElement(CharstringSubtypeTreeElement::ET_INTERSECTION,
1605           charstring_st, new CharstringSubtypeTreeElement(*(other->charstring_st)));
1606       }
1607     }
1608     break;
1609   case ST_UNIVERSAL_CHARSTRING:
1610     if (other->universal_charstring_st!=NULL) {
1611       if (universal_charstring_st==NULL) {
1612         universal_charstring_st = new UniversalCharstringSubtypeTreeElement(*(other->universal_charstring_st));
1613       } else {
1614         universal_charstring_st = new UniversalCharstringSubtypeTreeElement(UniversalCharstringSubtypeTreeElement::ET_INTERSECTION,
1615           universal_charstring_st, new UniversalCharstringSubtypeTreeElement(*(other->universal_charstring_st)));
1616       }
1617     }
1618     break;
1619   case ST_OBJID:
1620   case ST_RECORD:
1621   case ST_SET:
1622   case ST_ENUM:
1623   case ST_UNION:
1624   case ST_FUNCTION:
1625   case ST_ALTSTEP:
1626   case ST_TESTCASE:
1627     if (other->value_st!=NULL) {
1628       if (value_st==NULL) {
1629         value_st = new ValueListConstraint(*(other->value_st));
1630       } else {
1631         *value_st = *value_st * *(other->value_st);
1632       }
1633     }
1634     break;
1635   case ST_RECORDOF:
1636   case ST_SETOF:
1637     if (other->recof_st!=NULL) {
1638       if (recof_st==NULL) {
1639         recof_st = new RecofConstraint(*(other->recof_st));
1640       } else {
1641         *recof_st = *recof_st * *(other->recof_st);
1642       }
1643     }
1644     break;
1645   default:
1646     FATAL_ERROR("SubtypeConstraint::intersection()");
1647   }
1648   if (other->length_restriction!=NULL) {
1649     if (length_restriction==NULL) {
1650       length_restriction = new SizeRangeListConstraint(*(other->length_restriction));
1651     } else {
1652       *length_restriction = *length_restriction * *(other->length_restriction);
1653     }
1654   }
1655 }
1656
1657 tribool SubtypeConstraint::is_subset(const SubtypeConstraint* other) const
1658 {
1659   if (other==NULL) return TTRUE;
1660   if (other->subtype!=subtype) FATAL_ERROR("SubtypeConstraint::is_subset()");
1661   switch (subtype) {
1662   case ST_INTEGER:
1663     if (other->integer_st==NULL) return TTRUE;
1664     return integer_st ? integer_st->is_subset(*(other->integer_st)) : TTRUE;
1665   case ST_FLOAT:
1666     if (other->float_st==NULL) return TTRUE;
1667     return float_st ? float_st->is_subset(*(other->float_st)) : TTRUE;
1668   case ST_BOOLEAN:
1669     if (other->boolean_st==NULL) return TTRUE;
1670     return boolean_st ? boolean_st->is_subset(*(other->boolean_st)) : TTRUE;
1671   case ST_VERDICTTYPE:
1672     if (other->verdict_st==NULL) return TTRUE;
1673     return verdict_st ? verdict_st->is_subset(*(other->verdict_st)) : TTRUE;
1674   case ST_BITSTRING:
1675     if (other->bitstring_st==NULL) return TTRUE;
1676     return bitstring_st ? bitstring_st->is_subset(*(other->bitstring_st)) : TTRUE;
1677   case ST_HEXSTRING:
1678     if (other->hexstring_st==NULL) return TTRUE;
1679     return hexstring_st ? hexstring_st->is_subset(*(other->hexstring_st)) : TTRUE;
1680   case ST_OCTETSTRING:
1681     if (other->octetstring_st==NULL) return TTRUE;
1682     return octetstring_st ? octetstring_st->is_subset(*(other->octetstring_st)) : TTRUE;
1683   case ST_CHARSTRING:
1684     if (other->charstring_st==NULL) return TTRUE;
1685     return charstring_st ? charstring_st->is_subset(other->charstring_st) : TTRUE;
1686   case ST_UNIVERSAL_CHARSTRING:
1687     if (other->universal_charstring_st==NULL) return TTRUE;
1688     return universal_charstring_st ? universal_charstring_st->is_subset(other->universal_charstring_st) : TTRUE;
1689   case ST_OBJID:
1690   case ST_RECORD:
1691   case ST_SET:
1692   case ST_ENUM:
1693   case ST_UNION:
1694   case ST_FUNCTION:
1695   case ST_ALTSTEP:
1696   case ST_TESTCASE:
1697     if (other->value_st==NULL) return TTRUE;
1698     return value_st ? value_st->is_subset(*(other->value_st)) : TTRUE;
1699   case ST_RECORDOF:
1700   case ST_SETOF:
1701     if (other->recof_st==NULL) return TTRUE;
1702     return recof_st ? recof_st->is_subset(*(other->recof_st)) : TTRUE;
1703   default:
1704     FATAL_ERROR("SubtypeConstraint::is_subset()");
1705   }
1706   return TUNKNOWN;
1707 }
1708
1709 /********************
1710 class SubType
1711 ********************/
1712
1713 SubType::SubType(subtype_t st, Type *p_my_owner, SubType* p_parent_subtype,
1714   vector<SubTypeParse> *p_parsed, Constraints* p_asn_constraints)
1715 : SubtypeConstraint(st), my_owner(p_my_owner), parent_subtype(p_parent_subtype)
1716 , parsed(p_parsed), asn_constraints(p_asn_constraints)
1717 , root(0), extendable(false), extension(0), checked(STC_NO)
1718 , my_parents()
1719 {
1720   if (p_my_owner==NULL) FATAL_ERROR("SubType::SubType()");
1721 }
1722
1723 SubType::~SubType()
1724 {
1725   my_parents.clear();
1726 }
1727
1728 void SubType::chk_this_value(Value *value)
1729 {
1730   if (checked==STC_NO) FATAL_ERROR("SubType::chk_this_value()");
1731   if ((checked==STC_CHECKING) || (subtype==ST_ERROR)) return;
1732   Value *val = value->get_value_refd_last();
1733   bool is_invalid = false;
1734   switch (val->get_valuetype()) {
1735   case Value::V_INT:
1736     if (subtype!=ST_INTEGER) FATAL_ERROR("SubType::chk_this_value()");
1737     is_invalid = (integer_st!=NULL) && !integer_st->is_element(int_limit_t(*(val->get_val_Int())));
1738     break;
1739   case Value::V_REAL:
1740     if (subtype!=ST_FLOAT) FATAL_ERROR("SubType::chk_this_value()");
1741     is_invalid = (float_st!=NULL) && !float_st->is_element(val->get_val_Real());
1742     break;
1743   case Value::V_BOOL:
1744     if (subtype!=ST_BOOLEAN) FATAL_ERROR("SubType::chk_this_value()");
1745     is_invalid = (boolean_st!=NULL) && !boolean_st->is_element(val->get_val_bool());
1746     break;
1747   case Value::V_VERDICT: {
1748     if (subtype!=ST_VERDICTTYPE) FATAL_ERROR("SubType::chk_this_value()");
1749     VerdicttypeListConstraint::verdicttype_constraint_t vtc;
1750     switch (val->get_val_verdict()) {
1751     case Value::Verdict_NONE: vtc = VerdicttypeListConstraint::VC_NONE; break;
1752     case Value::Verdict_PASS: vtc = VerdicttypeListConstraint::VC_PASS; break;
1753     case Value::Verdict_INCONC: vtc = VerdicttypeListConstraint::VC_INCONC; break;
1754     case Value::Verdict_FAIL: vtc = VerdicttypeListConstraint::VC_FAIL; break;
1755     case Value::Verdict_ERROR: vtc = VerdicttypeListConstraint::VC_ERROR; break;
1756     default: FATAL_ERROR("SubType::chk_this_value()");
1757     }
1758     is_invalid = (verdict_st!=NULL) && !verdict_st->is_element(vtc);
1759   } break;
1760   case Value::V_BSTR:
1761     if (subtype!=ST_BITSTRING) FATAL_ERROR("SubType::chk_this_value()");
1762     is_invalid = (bitstring_st!=NULL) && !bitstring_st->is_element(val->get_val_str());
1763     break;
1764   case Value::V_HSTR:
1765     if (subtype!=ST_HEXSTRING) FATAL_ERROR("SubType::chk_this_value()");
1766     is_invalid = (hexstring_st!=NULL) && !hexstring_st->is_element(val->get_val_str());
1767     break;
1768   case Value::V_OSTR:
1769     if (subtype!=ST_OCTETSTRING) FATAL_ERROR("SubType::chk_this_value()");
1770     is_invalid = (octetstring_st!=NULL) && !octetstring_st->is_element(val->get_val_str());
1771     break;
1772   case Value::V_CSTR:
1773   case Value::V_ISO2022STR:
1774     if (subtype!=ST_CHARSTRING) FATAL_ERROR("SubType::chk_this_value()");
1775     is_invalid = (charstring_st!=NULL) && !charstring_st->is_element(val->get_val_str());
1776     break;
1777   case Value::V_USTR:
1778   case Value::V_CHARSYMS:
1779     if (subtype!=ST_UNIVERSAL_CHARSTRING) FATAL_ERROR("SubType::chk_this_value()");
1780     is_invalid = (universal_charstring_st!=NULL) && !universal_charstring_st->is_element(val->get_val_ustr());
1781     break;
1782   case Value::V_SEQOF:
1783     if (subtype!=ST_RECORDOF) FATAL_ERROR("SubType::chk_this_value()");
1784     if (value->is_unfoldable()) return;
1785     is_invalid = (recof_st!=NULL) && !recof_st->is_element(val);
1786     break;
1787   case Value::V_SETOF:
1788     if (subtype!=ST_SETOF) FATAL_ERROR("SubType::chk_this_value()");
1789     if (value->is_unfoldable()) return;
1790     is_invalid = (recof_st!=NULL) && !recof_st->is_element(val);
1791     break;
1792   case Value::V_OID:
1793   case Value::V_ROID:
1794     if (subtype!=ST_OBJID) FATAL_ERROR("SubType::chk_this_value()");
1795     if (value->is_unfoldable()) return;
1796     is_invalid = (value_st!=NULL) && !value_st->is_element(val);
1797     break;
1798   case Value::V_ENUM:
1799   case Value::V_NULL: // FIXME: should go to ST_NULL
1800     if (subtype!=ST_ENUM) FATAL_ERROR("SubType::chk_this_value()");
1801     if (value->is_unfoldable()) return;
1802     is_invalid = (value_st!=NULL) && !value_st->is_element(val);
1803     break;
1804   case Value::V_CHOICE:
1805   case Value::V_OPENTYPE: // FIXME?
1806     if (subtype!=ST_UNION) FATAL_ERROR("SubType::chk_this_value()");
1807     if (value->is_unfoldable()) return;
1808     is_invalid = (value_st!=NULL) && !value_st->is_element(val);
1809     break;
1810   case Value::V_SEQ:
1811     if (subtype!=ST_RECORD) FATAL_ERROR("SubType::chk_this_value()");
1812     if (value->is_unfoldable()) return;
1813     is_invalid = (value_st!=NULL) && !value_st->is_element(val);
1814     break;
1815   case Value::V_SET:
1816     if (subtype!=ST_SET) FATAL_ERROR("SubType::chk_this_value()");
1817     if (value->is_unfoldable()) return;
1818     is_invalid = (value_st!=NULL) && !value_st->is_element(val);
1819     break;
1820   case Value::V_FUNCTION:
1821     if (subtype!=ST_FUNCTION) FATAL_ERROR("SubType::chk_this_value()");
1822     if (value->is_unfoldable()) return;
1823     is_invalid = (value_st!=NULL) && !value_st->is_element(val);
1824     break;
1825   case Value::V_ALTSTEP:
1826     if (subtype!=ST_ALTSTEP) FATAL_ERROR("SubType::chk_this_value()");
1827     if (value->is_unfoldable()) return;
1828     is_invalid = (value_st!=NULL) && !value_st->is_element(val);
1829     break;
1830   case Value::V_TESTCASE:
1831     if (subtype!=ST_TESTCASE) FATAL_ERROR("SubType::chk_this_value()");
1832     if (value->is_unfoldable()) return;
1833     is_invalid = (value_st!=NULL) && !value_st->is_element(val);
1834     break;
1835   case Value::V_ERROR:
1836     return;
1837   default:
1838     return;
1839   }
1840   if (is_invalid) {
1841     value->error("%s is not a valid value for type `%s' which has subtype %s",
1842       val->get_stringRepr().c_str(),
1843       my_owner->get_typename().c_str(),
1844       to_string().c_str());
1845   }
1846 }
1847
1848 /** \todo revise */
1849 void SubType::chk_this_template_generic(Template *templ)
1850 {
1851   if (checked==STC_NO) FATAL_ERROR("SubType::chk_this_template_generic()");
1852   if ((checked==STC_CHECKING) || (subtype==ST_ERROR)) return;
1853   templ = templ->get_template_refd_last();
1854   switch (templ->get_templatetype()) {
1855   case Ttcn::Template::OMIT_VALUE:
1856   case Ttcn::Template::ANY_OR_OMIT:
1857   case Ttcn::Template::TEMPLATE_ERROR:
1858   case Ttcn::Template::ANY_VALUE:
1859     break;
1860   case Ttcn::Template::VALUE_LIST:
1861   case Ttcn::Template::COMPLEMENTED_LIST:
1862     /* Should be canonical before */
1863     break;
1864   case Ttcn::Template::SPECIFIC_VALUE:
1865     /* SPECIFIC_VALUE must be already checked in Type::chk_this_template() */
1866     break;
1867   case Ttcn::Template::TEMPLATE_REFD:
1868     /* unfoldable reference: cannot be checked at compile time */
1869     break;
1870   case Ttcn::Template::TEMPLATE_INVOKE:
1871     /* should be already checked in Type::chk_this_template() */
1872     break;
1873   default:
1874     chk_this_template(templ);
1875     break;
1876   }
1877   chk_this_template_length_restriction(templ);
1878 }
1879
1880 /** \todo revise */
1881 void SubType::chk_this_template(Template *templ)
1882 {
1883   switch (templ->get_templatetype()) {
1884   case Template::TEMPLATE_LIST:
1885     if ( (length_restriction!=NULL) && !length_restriction->is_empty() ) {
1886       size_t nof_comp_woaon = templ->get_nof_comps_not_anyornone();
1887       if (!templ->temps_contains_anyornone_symbol() &&
1888         nof_comp_woaon < length_restriction->get_minimal().get_size()) {
1889         templ->error("At least %s elements must be present in the list",
1890           Int2string((Int)(length_restriction->get_minimal().get_size())).c_str());
1891         return;
1892       } else if ( !length_restriction->get_maximal().get_infinity() && (nof_comp_woaon > length_restriction->get_maximal().get_size()) ) {
1893         templ->error("There must not be more than %s elements in the list",
1894           Int2string((Int)(length_restriction->get_maximal().get_size())).c_str());
1895         return;
1896       }
1897     }
1898     break;
1899   /* Simply break.  We don't know how many elements are there.
1900        SUPERSET_MATCH/SUBSET_MATCH is not possible to be an
1901        INDEXED_TEMPLATE_LIST.  */
1902   case Template::INDEXED_TEMPLATE_LIST:
1903     break;
1904   case Template::NAMED_TEMPLATE_LIST:
1905     break;
1906   case Template::VALUE_RANGE:
1907     /* Should be canonical before */
1908     break;
1909   case Template::SUPERSET_MATCH:
1910   case Template::SUBSET_MATCH:
1911     if (subtype!=ST_SETOF){
1912       templ->error("'subset' template matching mechanism can be used "
1913         "only with 'set of' types");
1914       return;
1915     }
1916     for (size_t i=0;i<templ->get_nof_comps();i++)
1917       chk_this_template_generic(templ->get_temp_byIndex(i));
1918     break;
1919   case Template::BSTR_PATTERN:
1920     chk_this_template_pattern("bitstring", templ);
1921     break;
1922   case Template::HSTR_PATTERN:
1923     chk_this_template_pattern("hexstring", templ);
1924     break;
1925   case Template::OSTR_PATTERN:
1926     chk_this_template_pattern("octetstring", templ);
1927     break;
1928   case Template::CSTR_PATTERN:
1929     chk_this_template_pattern("charstring", templ);
1930     break;
1931   case Template::USTR_PATTERN:
1932           chk_this_template_pattern("universal charstring", templ);
1933           break;
1934   case Template::TEMPLATE_ERROR:
1935     break;
1936   default:
1937     FATAL_ERROR("SubType::chk_this_template()");
1938     break;
1939   }
1940 }
1941
1942 void SubType::chk_this_template_length_restriction(Template *templ)
1943 {
1944   if (!templ->is_length_restricted()) return;
1945   // if there is a length restriction on the template then check if
1946   // the intersection of the two restrictions is not empty
1947   size_limit_t tmpl_min_len(size_limit_t(0));
1948   size_limit_t tmpl_max_len(size_limit_t::INFINITE_SIZE);
1949   Ttcn::LengthRestriction *lr=templ->get_length_restriction();
1950   lr->chk(Type::EXPECTED_DYNAMIC_VALUE);
1951   if (!lr->get_is_range()) { //Template's lr is single
1952     Value *tmp_val=lr->get_single_value();
1953     if (tmp_val->get_valuetype()!=Value::V_INT) return;
1954     Int templ_len = tmp_val->get_val_Int()->get_val();
1955     tmpl_min_len = tmpl_max_len = size_limit_t((size_t)templ_len);
1956   } else { //Template's lr is range
1957     Value *tmp_lower=lr->get_lower_value();
1958     if (tmp_lower->get_valuetype()!=Value::V_INT) return;
1959     Int templ_lower = tmp_lower->get_val_Int()->get_val();
1960     tmpl_min_len = size_limit_t((size_t)templ_lower);
1961     Value *tmp_upper=lr->get_upper_value();
1962     if (tmp_upper && tmp_upper->get_valuetype()!=Value::V_INT) return;
1963     if (tmp_upper) tmpl_max_len = size_limit_t((size_t)tmp_upper->get_val_Int()->get_val());
1964   }
1965
1966   bool is_err = false;
1967   switch (subtype) {
1968   case ST_BITSTRING:
1969     if (bitstring_st!=NULL) {
1970       BitstringConstraint bc = *bitstring_st * BitstringConstraint(tmpl_min_len,tmpl_max_len);
1971       if (bc.is_empty()==TTRUE) is_err = true;
1972     }
1973     break;
1974   case ST_HEXSTRING:
1975     if (hexstring_st!=NULL) {
1976       HexstringConstraint hc = *hexstring_st * HexstringConstraint(tmpl_min_len,tmpl_max_len);
1977       if (hc.is_empty()==TTRUE) is_err = true;
1978     }
1979     break;
1980   case ST_OCTETSTRING:
1981     if (octetstring_st!=NULL) {
1982       OctetstringConstraint oc = *octetstring_st * OctetstringConstraint(tmpl_min_len,tmpl_max_len);
1983       if (oc.is_empty()==TTRUE) is_err = true;
1984     }
1985     break;
1986   case ST_CHARSTRING:
1987     if (charstring_st!=NULL) {
1988       CharstringSubtypeTreeElement* cc = new CharstringSubtypeTreeElement(
1989         CharstringSubtypeTreeElement::ET_INTERSECTION,
1990         new CharstringSubtypeTreeElement(*charstring_st),
1991         new CharstringSubtypeTreeElement(SizeRangeListConstraint(tmpl_min_len,tmpl_max_len))
1992       );
1993       if (cc->is_empty()==TTRUE) is_err = true;
1994       delete cc;
1995     }
1996     break;
1997   case ST_UNIVERSAL_CHARSTRING:
1998     if (universal_charstring_st!=NULL) {
1999       UniversalCharstringSubtypeTreeElement* ucc = new UniversalCharstringSubtypeTreeElement(
2000         UniversalCharstringSubtypeTreeElement::ET_INTERSECTION,
2001         new UniversalCharstringSubtypeTreeElement(*universal_charstring_st),
2002         new UniversalCharstringSubtypeTreeElement(SizeRangeListConstraint(tmpl_min_len,tmpl_max_len))
2003       );
2004       if (ucc->is_empty()==TTRUE) is_err = true;
2005       delete ucc;
2006     }
2007     break;
2008   case ST_RECORDOF:
2009   case ST_SETOF:
2010     if (recof_st!=NULL) {
2011       RecofConstraint rc = *recof_st * RecofConstraint(tmpl_min_len,tmpl_max_len);
2012       if (rc.is_empty()==TTRUE) is_err = true;
2013     }
2014     break;
2015   default:
2016     break;
2017   }
2018   if (is_err) {
2019     templ->error("Template's length restriction %s is outside of the type's subtype constraint %s",
2020       SizeRangeListConstraint(tmpl_min_len,tmpl_max_len).to_string().c_str(), to_string().c_str());
2021   }
2022 }
2023
2024 void SubType::chk_this_template_pattern(const char *patt_type, Template *templ)
2025 {
2026   Template::templatetype_t temptype= templ->get_templatetype();
2027   if ((temptype==Template::BSTR_PATTERN && subtype!=ST_BITSTRING) ||
2028     (temptype==Template::HSTR_PATTERN && subtype!=ST_HEXSTRING) ||
2029     (temptype==Template::OSTR_PATTERN && subtype!=ST_OCTETSTRING) ||
2030     (temptype==Template::CSTR_PATTERN && subtype!=ST_CHARSTRING) ||
2031     (temptype==Template::USTR_PATTERN && subtype!=ST_UNIVERSAL_CHARSTRING))
2032   {
2033     templ->error("Template is incompatible with subtype");
2034     return;
2035   }
2036   if ( (length_restriction!=NULL) && !length_restriction->is_empty() ) {
2037     Int patt_min_len = static_cast<Int>(templ->get_min_length_of_pattern());
2038     if (patt_min_len < (Int)(length_restriction->get_minimal().get_size()) &&
2039       !templ->pattern_contains_anyornone_symbol()) {
2040       templ->error("At least %s string elements must be present in the %s",
2041         Int2string((Int)(length_restriction->get_minimal().get_size())).c_str(), patt_type);
2042     } else if ( !length_restriction->get_maximal().get_infinity() && (patt_min_len > (Int)(length_restriction->get_maximal().get_size())) ) {
2043       templ->error("There must not be more than %s string elements in the %s",
2044         Int2string((Int)(length_restriction->get_maximal().get_size())).c_str(), patt_type);
2045     }
2046   }
2047 }
2048
2049 void SubType::add_ttcn_value(Value *v)
2050 {
2051   if (value_st==NULL) value_st = new ValueListConstraint(v);
2052   else *value_st = *value_st + ValueListConstraint(v);
2053 }
2054
2055 void SubType::add_ttcn_recof(Value *v)
2056 {
2057   if (recof_st==NULL) recof_st = new RecofConstraint(v);
2058   else *recof_st = *recof_st + RecofConstraint(v);
2059 }
2060
2061 bool SubType::add_ttcn_type_list_subtype(SubType* p_st)
2062 {
2063   switch (subtype) {
2064   case ST_INTEGER:
2065     if (p_st->integer_st==NULL) return false;
2066     if (integer_st==NULL) integer_st = new IntegerRangeListConstraint(*(p_st->integer_st));
2067     else *integer_st = *integer_st + *(p_st->integer_st);
2068     break;
2069   case ST_FLOAT:
2070     if (p_st->float_st==NULL) return false;
2071     if (float_st==NULL) float_st = new RealRangeListConstraint(*(p_st->float_st));
2072     else *float_st = *float_st + *(p_st->float_st);
2073     break;
2074   case ST_BOOLEAN:
2075     if (p_st->boolean_st==NULL) return false;
2076     if (boolean_st==NULL) boolean_st = new BooleanListConstraint(*(p_st->boolean_st));
2077     else *boolean_st = *boolean_st + *(p_st->boolean_st);
2078     break;
2079   case ST_VERDICTTYPE:
2080     if (p_st->verdict_st==NULL) return false;
2081     if (verdict_st==NULL) verdict_st = new VerdicttypeListConstraint(*(p_st->verdict_st));
2082     else *verdict_st = *verdict_st + *(p_st->verdict_st);
2083     break;
2084   case ST_BITSTRING:
2085     if (p_st->bitstring_st==NULL) return false;
2086     if (bitstring_st==NULL) bitstring_st = new BitstringConstraint(*(p_st->bitstring_st));
2087     else *bitstring_st = *bitstring_st + *(p_st->bitstring_st);
2088     break;
2089   case ST_HEXSTRING:
2090     if (p_st->hexstring_st==NULL) return false;
2091     if (hexstring_st==NULL) hexstring_st = new HexstringConstraint(*(p_st->hexstring_st));
2092     else *hexstring_st = *hexstring_st + *(p_st->hexstring_st);
2093     break;
2094   case ST_OCTETSTRING:
2095     if (p_st->octetstring_st==NULL) return false;
2096     if (octetstring_st==NULL) octetstring_st = new OctetstringConstraint(*(p_st->octetstring_st));
2097     else *octetstring_st = *octetstring_st + *(p_st->octetstring_st);
2098     break;
2099   case ST_CHARSTRING:
2100     if (p_st->charstring_st==NULL) return false;
2101     if (charstring_st==NULL) {
2102       charstring_st = new CharstringSubtypeTreeElement(*(p_st->charstring_st));
2103     } else {
2104       charstring_st = new CharstringSubtypeTreeElement(
2105         CharstringSubtypeTreeElement::ET_UNION,
2106         charstring_st,
2107         new CharstringSubtypeTreeElement(*(p_st->charstring_st)));
2108     }
2109     break;
2110   case ST_UNIVERSAL_CHARSTRING:
2111     if (p_st->universal_charstring_st==NULL) return false;
2112     if (universal_charstring_st==NULL) {
2113       universal_charstring_st = new UniversalCharstringSubtypeTreeElement(*(p_st->universal_charstring_st));
2114     } else {
2115       universal_charstring_st = new UniversalCharstringSubtypeTreeElement(
2116         UniversalCharstringSubtypeTreeElement::ET_UNION,
2117         universal_charstring_st,
2118         new UniversalCharstringSubtypeTreeElement(*(p_st->universal_charstring_st)));
2119     }
2120     break;
2121   case ST_OBJID:
2122   case ST_RECORD:
2123   case ST_SET:
2124   case ST_ENUM:
2125   case ST_UNION:
2126   case ST_FUNCTION:
2127   case ST_ALTSTEP:
2128   case ST_TESTCASE:
2129     if (p_st->value_st==NULL) return false;
2130     if (value_st==NULL) value_st = new ValueListConstraint(*(p_st->value_st));
2131     else *value_st = *value_st + *(p_st->value_st);
2132     break;
2133   case ST_RECORDOF:
2134   case ST_SETOF:
2135     if (p_st->recof_st==NULL) return false;
2136     if (recof_st==NULL) recof_st = new RecofConstraint(*(p_st->recof_st));
2137     else *recof_st = *recof_st + *(p_st->recof_st);
2138     break;
2139   default:
2140     FATAL_ERROR("SubType::add_ttcn_type_list_subtype()");
2141   }
2142   return true;
2143 }
2144
2145
2146 bool SubType::add_parent_subtype(SubType* st)
2147 {
2148   if (st==NULL) FATAL_ERROR("SubType::add_parent_subtype()");
2149   if (my_parents.has_key(st)) return true; // it was already successfully added -> ignore
2150   ReferenceChain refch(my_owner, "While checking circular type references in subtype definitions");
2151   refch.add(my_owner->get_fullname()); // current type
2152   // recursive check for all parents of referenced type
2153   if (!st->chk_recursion(refch)) return false;
2154   // if no recursion was detected then add the referenced type as parent
2155   my_parents.add(st,NULL);
2156   return true;
2157 }
2158
2159 bool SubType::chk_recursion(ReferenceChain& refch)
2160 {
2161   if (!refch.add(my_owner->get_fullname())) return false; // try the referenced type
2162   for (size_t i = 0; i < my_parents.size(); i++) {
2163     refch.mark_state();
2164     if (!my_parents.get_nth_key(i)->chk_recursion(refch)) return false;
2165     refch.prev_state();
2166   }
2167   return true;
2168 }
2169
2170 bool SubType::add_ttcn_single(Value *val, size_t restriction_index)
2171 {
2172   val->set_my_scope(my_owner->get_my_scope());
2173   val->set_my_governor(my_owner);
2174   val->set_fullname(my_owner->get_fullname()+".<single_restriction_"+Int2string(restriction_index) + ">");
2175   my_owner->chk_this_value_ref(val);
2176
2177   // check if this is type reference, if not then fall through
2178   if (val->get_valuetype()==Value::V_REFD) {
2179     Reference* ref = val->get_reference();
2180     Assignment *ass = ref->get_refd_assignment();
2181     if (ass==NULL) return false; // defintion was not found, error was reported
2182     if (ass->get_asstype()==Assignment::A_TYPE) {
2183       Type* t = ass->get_Type();
2184       t->chk();
2185       if (t->get_typetype()==Type::T_ERROR) return false;
2186       // if there were subreferences then get the referenced field's type
2187       if (ref->get_subrefs()) {
2188         t = t->get_field_type(ref->get_subrefs(), Type::EXPECTED_CONSTANT);
2189         if ( (t==NULL) || (t->get_typetype()==Type::T_ERROR) ) return false;
2190         t->chk();
2191         if (t->get_typetype()==Type::T_ERROR) return false;
2192       }
2193       if (!t->is_identical(my_owner)) {
2194         val->error("Reference `%s' must refer to a type which has the same root type as this type",
2195                    val->get_reference()->get_dispname().c_str());
2196         return false;
2197       }
2198       // check subtype of referenced type
2199       SubType* t_st = t->get_sub_type();
2200       if (t_st==NULL) {
2201         val->error("Type referenced by `%s' does not have a subtype",
2202                    val->get_reference()->get_dispname().c_str());
2203         return false;
2204       }
2205
2206       // check circular subtype reference
2207       if (!add_parent_subtype(t_st)) return false;
2208
2209       if (t_st->get_subtypetype()==ST_ERROR) return false;
2210       if (t_st->get_subtypetype()!=subtype) FATAL_ERROR("SubType::add_ttcn_single()");
2211       // add the subtype as union
2212       bool added = add_ttcn_type_list_subtype(t_st);
2213       if (!added) {
2214         val->error("Type referenced by `%s' does not have a subtype",
2215                    val->get_reference()->get_dispname().c_str());
2216       }
2217       return added;
2218     }
2219   }
2220
2221   my_owner->chk_this_value(val, 0, Type::EXPECTED_CONSTANT,
2222     INCOMPLETE_NOT_ALLOWED, OMIT_NOT_ALLOWED, NO_SUB_CHK);
2223
2224   Value *v=val->get_value_refd_last();
2225
2226   switch (v->get_valuetype()) {
2227   case Value::V_INT:
2228     if (subtype!=ST_INTEGER) FATAL_ERROR("SubType::add_ttcn_single()");
2229     if (integer_st==NULL) integer_st = new IntegerRangeListConstraint(int_limit_t(*(v->get_val_Int())));
2230     else *integer_st = *integer_st + IntegerRangeListConstraint(int_limit_t(*(v->get_val_Int())));
2231     break;
2232   case Value::V_REAL: {
2233     if (subtype!=ST_FLOAT) FATAL_ERROR("SubType::add_ttcn_single()");
2234     ttcn3float r = v->get_val_Real();
2235     if (r!=r) {
2236       if (float_st==NULL) float_st = new RealRangeListConstraint(true);
2237       else *float_st = *float_st + RealRangeListConstraint(true);
2238     } else {
2239       if (float_st==NULL) float_st = new RealRangeListConstraint(real_limit_t(r));
2240       else *float_st = *float_st + RealRangeListConstraint(real_limit_t(r));
2241     }
2242   } break;
2243   case Value::V_BOOL:
2244     if (subtype!=ST_BOOLEAN) FATAL_ERROR("SubType::add_ttcn_single()");
2245     if (boolean_st==NULL) boolean_st = new BooleanListConstraint(v->get_val_bool());
2246     else *boolean_st = *boolean_st + BooleanListConstraint(v->get_val_bool());
2247     break;
2248   case Value::V_VERDICT: {
2249     if (subtype!=ST_VERDICTTYPE) FATAL_ERROR("SubType::add_ttcn_single()");
2250     VerdicttypeListConstraint::verdicttype_constraint_t vtc;
2251     switch (v->get_val_verdict()) {
2252     case Value::Verdict_NONE: vtc = VerdicttypeListConstraint::VC_NONE; break;
2253     case Value::Verdict_PASS: vtc = VerdicttypeListConstraint::VC_PASS; break;
2254     case Value::Verdict_INCONC: vtc = VerdicttypeListConstraint::VC_INCONC; break;
2255     case Value::Verdict_FAIL: vtc = VerdicttypeListConstraint::VC_FAIL; break;
2256     case Value::Verdict_ERROR: vtc = VerdicttypeListConstraint::VC_ERROR; break;
2257     default: FATAL_ERROR("SubType::add_ttcn_single()");
2258     }
2259     if (verdict_st==NULL) verdict_st = new VerdicttypeListConstraint(vtc);
2260     else *verdict_st = *verdict_st + VerdicttypeListConstraint(vtc);
2261   } break;
2262   case Value::V_OID:
2263     if (v->has_oid_error()) return false;
2264     if (subtype!=ST_OBJID) FATAL_ERROR("SubType::add_ttcn_single()");
2265     if (value_st==NULL) value_st = new ValueListConstraint(v);
2266     else *value_st = *value_st + ValueListConstraint(v);
2267     break;
2268   case Value::V_BSTR:
2269     if (subtype!=ST_BITSTRING) FATAL_ERROR("SubType::add_ttcn_single()");
2270     if (bitstring_st==NULL) bitstring_st = new BitstringConstraint(v->get_val_str());
2271     else *bitstring_st = *bitstring_st + BitstringConstraint(v->get_val_str());
2272     break;
2273   case Value::V_HSTR:
2274     if (subtype!=ST_HEXSTRING) FATAL_ERROR("SubType::add_ttcn_single()");
2275     if (hexstring_st==NULL) hexstring_st = new HexstringConstraint(v->get_val_str());
2276     else *hexstring_st = *hexstring_st + HexstringConstraint(v->get_val_str());
2277     break;
2278   case Value::V_OSTR:
2279     if (subtype!=ST_OCTETSTRING) FATAL_ERROR("SubType::add_ttcn_single()");
2280     if (octetstring_st==NULL) octetstring_st = new OctetstringConstraint(v->get_val_str());
2281     else *octetstring_st = *octetstring_st + OctetstringConstraint(v->get_val_str());
2282     break;
2283   case Value::V_CSTR: {
2284     if (subtype!=ST_CHARSTRING) FATAL_ERROR("SubType::add_ttcn_single()");
2285     CharstringSubtypeTreeElement* cst_elem = new CharstringSubtypeTreeElement(StringValueConstraint<string>(v->get_val_str()));
2286     if (charstring_st==NULL) charstring_st = cst_elem;
2287     else charstring_st = new CharstringSubtypeTreeElement(CharstringSubtypeTreeElement::ET_UNION, charstring_st, cst_elem);
2288   } break;
2289   case Value::V_USTR: {
2290     if (subtype!=ST_UNIVERSAL_CHARSTRING) FATAL_ERROR("SubType::add_ttcn_single()");
2291     UniversalCharstringSubtypeTreeElement* ucst_elem = new UniversalCharstringSubtypeTreeElement(StringValueConstraint<ustring>(v->get_val_ustr()));
2292     if (universal_charstring_st==NULL) universal_charstring_st = ucst_elem;
2293     else universal_charstring_st = new UniversalCharstringSubtypeTreeElement(UniversalCharstringSubtypeTreeElement::ET_UNION, universal_charstring_st, ucst_elem);
2294   } break;
2295   case Value::V_ENUM:
2296   case Value::V_NULL: // FIXME: should go to ST_NULL
2297     if (subtype!=ST_ENUM) FATAL_ERROR("SubType::add_ttcn_single()");
2298     add_ttcn_value(v);
2299     break;
2300   case Value::V_CHOICE:
2301     if (subtype!=ST_UNION) FATAL_ERROR("SubType::add_ttcn_single()");
2302     add_ttcn_value(v);
2303     break;
2304   case Value::V_SEQ:
2305     if (subtype!=ST_RECORD) FATAL_ERROR("SubType::add_ttcn_single()");
2306     add_ttcn_value(v);
2307     break;
2308   case Value::V_SET:
2309     if (subtype!=ST_SET) FATAL_ERROR("SubType::add_ttcn_single()");
2310     add_ttcn_value(v);
2311     break;
2312   case Value::V_FUNCTION:
2313     if (subtype!=ST_FUNCTION) FATAL_ERROR("SubType::add_ttcn_single()");
2314     add_ttcn_value(v);
2315     break;
2316   case Value::V_ALTSTEP:
2317     if (subtype!=ST_ALTSTEP) FATAL_ERROR("SubType::add_ttcn_single()");
2318     add_ttcn_value(v);
2319     break;
2320   case Value::V_TESTCASE:
2321     if (subtype!=ST_TESTCASE) FATAL_ERROR("SubType::add_ttcn_single()");
2322     add_ttcn_value(v);
2323     break;
2324   case Value::V_SEQOF:
2325     if (subtype!=ST_RECORDOF) FATAL_ERROR("SubType::add_ttcn_single()");
2326     add_ttcn_recof(v);
2327     break;
2328   case Value::V_SETOF:
2329     if (subtype!=ST_SETOF) FATAL_ERROR("SubType::add_ttcn_single()");
2330     add_ttcn_recof(v);
2331     break;
2332   case Value::V_ERROR:
2333     return false;
2334   default:
2335     return false;
2336   }
2337   return true;
2338 }
2339
2340 bool SubType::add_ttcn_range(Value *min, bool min_exclusive,
2341   Value *max, bool max_exclusive, size_t restriction_index, bool has_other)
2342 {
2343   switch (subtype) {
2344   case ST_INTEGER:
2345   case ST_FLOAT:
2346   case ST_CHARSTRING:
2347   case ST_UNIVERSAL_CHARSTRING:
2348     break;
2349   default:
2350     my_owner->error("Range subtyping is not allowed for type `%s'",
2351       my_owner->get_typename().c_str());
2352     return false;
2353   }
2354
2355   Value *vmin,*vmax;
2356   if (min==NULL) vmin=NULL;
2357   else {
2358     min->set_my_scope(my_owner->get_my_scope());
2359     min->set_fullname(my_owner->get_fullname()+".<range_restriction_"+Int2string(restriction_index)+"_lower>");
2360     my_owner->chk_this_value_ref(min);
2361     my_owner->chk_this_value(min, 0, Type::EXPECTED_CONSTANT,
2362       INCOMPLETE_NOT_ALLOWED, OMIT_NOT_ALLOWED, NO_SUB_CHK);
2363     vmin=min->get_value_refd_last();
2364   }
2365   if (max==NULL) vmax=NULL;
2366   else {
2367     max->set_my_scope(my_owner->get_my_scope());
2368     max->set_fullname(my_owner->get_fullname()+".<range_restriction_"+Int2string(restriction_index)+"_upper>");
2369     my_owner->chk_this_value_ref(max);
2370     my_owner->chk_this_value(max, 0, Type::EXPECTED_CONSTANT,
2371       INCOMPLETE_NOT_ALLOWED, OMIT_NOT_ALLOWED, NO_SUB_CHK);
2372     vmax=max->get_value_refd_last();
2373   }
2374
2375   if ( (vmin!=NULL) && (vmax!=NULL) && (vmin->get_valuetype()!=vmax->get_valuetype()) ) return false;
2376
2377   switch (subtype) {
2378   case ST_INTEGER: {
2379     if (((vmin!=NULL) && (vmin->get_valuetype()!=Value::V_INT)) ||
2380         ((vmax!=NULL) && (vmax->get_valuetype()!=Value::V_INT))) return false;
2381     int_limit_t min_limit = (vmin!=NULL) ? int_limit_t(*(vmin->get_val_Int())) : int_limit_t::minimum;
2382     if (min_exclusive) {
2383       if (min_limit==int_limit_t::minimum) {
2384         my_owner->error("invalid lower boundary, -infinity cannot be excluded from an integer subtype range");
2385         return false;
2386       } else {
2387         if (min_limit==int_limit_t::maximum) {
2388           my_owner->error("!infinity is not a valid lower boundary");
2389           return false;
2390         }
2391         min_limit = min_limit.next();
2392       }
2393     }
2394     int_limit_t max_limit = (vmax!=NULL) ? int_limit_t(*(vmax->get_val_Int())) : int_limit_t::maximum;
2395     if (max_exclusive) {
2396       if (max_limit==int_limit_t::maximum) {
2397         my_owner->error("invalid upper boundary, infinity cannot be excluded from an integer subtype range");
2398         return false;
2399       } else {
2400         if (max_limit==int_limit_t::minimum) {
2401           my_owner->error("!-infinity is not a valid upper boundary");
2402           return false;
2403         }
2404         max_limit = max_limit.previous();
2405       }
2406     }
2407     if (max_limit<min_limit) {
2408       my_owner->error("lower boundary is bigger than upper boundary in integer subtype range");
2409       return false;
2410     }
2411     if (integer_st==NULL) integer_st = new IntegerRangeListConstraint(min_limit, max_limit);
2412     else *integer_st = *integer_st + IntegerRangeListConstraint(min_limit, max_limit);
2413   } break;
2414   case ST_FLOAT: {
2415     if (((vmin!=NULL) && (vmin->get_valuetype()!=Value::V_REAL)) ||
2416         ((vmax!=NULL) && (vmax->get_valuetype()!=Value::V_REAL))) return false;
2417     if ((vmin!=NULL) && (vmin->get_val_Real()!=vmin->get_val_Real())) {
2418       my_owner->error("lower boundary cannot be not_a_number in float subtype range");
2419       return false;
2420     }
2421     if ((vmax!=NULL) && (vmax->get_val_Real()!=vmax->get_val_Real())) {
2422       my_owner->error("upper boundary cannot be not_a_number in float subtype range");
2423       return false;
2424     }
2425     real_limit_t min_limit = (vmin!=NULL) ? real_limit_t(vmin->get_val_Real()) : real_limit_t::minimum;
2426     if (min_exclusive) {
2427       if (min_limit==real_limit_t::maximum) {
2428         my_owner->error("!infinity is not a valid lower boundary");
2429         return false;
2430       }
2431       min_limit = min_limit.next();
2432     }
2433     real_limit_t max_limit = (vmax!=NULL) ? real_limit_t(vmax->get_val_Real()) : real_limit_t::maximum;
2434     if (max_exclusive) {
2435       if (max_limit==real_limit_t::minimum) {
2436         my_owner->error("!-infinity is not a valid upper boundary");
2437         return false;
2438       }
2439       max_limit = max_limit.previous();
2440     }
2441     if (max_limit<min_limit) {
2442       my_owner->error("lower boundary is bigger than upper boundary in float subtype range");
2443       return false;
2444     }
2445     if (float_st==NULL) float_st = new RealRangeListConstraint(min_limit, max_limit);
2446     else *float_st = *float_st + RealRangeListConstraint(min_limit, max_limit);
2447   } break;
2448   case ST_CHARSTRING: {
2449     if (((vmin!=NULL) && (vmin->get_valuetype()!=Value::V_CSTR)) ||
2450         ((vmax!=NULL) && (vmax->get_valuetype()!=Value::V_CSTR))) return false;
2451     if ((vmin==NULL)&&(vmax==NULL)) {
2452       my_owner->error("a range subtype of a charstring cannot be (-infinity..infinity)");
2453       return false;
2454     }
2455     if (vmin==NULL) {
2456       my_owner->error("lower boundary of a charstring subtype range cannot be -infinity");
2457       return false;
2458     }
2459     if (vmax==NULL) {
2460       my_owner->error("upper boundary of a charstring subtype range cannot be infinity");
2461       return false;
2462     }
2463     if (vmin->get_val_str().size()!=1) {
2464       min->error("lower boundary of charstring subtype range must be a single element string");
2465       return false;
2466     }
2467     if (vmax->get_val_str().size()!=1) {
2468       max->error("upper boundary of charstring subtype range must be a single element string");
2469       return false;
2470     }
2471     if (!char_limit_t::is_valid_value(*vmin->get_val_str().c_str())) {
2472       min->error("lower boundary of charstring subtype range is an invalid char");
2473       return false;
2474     }
2475     if (!char_limit_t::is_valid_value(*vmax->get_val_str().c_str())) {
2476       max->error("upper boundary of charstring subtype range is an invalid char");
2477       return false;
2478     }
2479     char_limit_t min_limit(*vmin->get_val_str().c_str()), max_limit(*vmax->get_val_str().c_str());
2480     if (min_exclusive) {
2481       if (min_limit==char_limit_t::maximum) {
2482         min->error("exclusive lower boundary is not a legal charstring character");
2483         return false;
2484       }
2485       min_limit = min_limit.next();
2486     }
2487     if (max_exclusive) {
2488       if (max_limit==char_limit_t::minimum) {
2489         max->error("exclusive upper boundary is not a legal charstring character");
2490         return false;
2491       }
2492       max_limit = max_limit.previous();
2493     }
2494     if (max_limit<min_limit) {
2495       my_owner->error("lower boundary is bigger than upper boundary in charstring subtype range");
2496       return false;
2497     }
2498     if (charstring_st==NULL) charstring_st = new CharstringSubtypeTreeElement(CharRangeListConstraint(min_limit,max_limit), false);
2499     else {
2500       if (!has_other) { // union in char context can be done only with range constraints
2501         charstring_st->set_char_context(true);
2502         charstring_st = new CharstringSubtypeTreeElement(CharstringSubtypeTreeElement::ET_UNION,
2503           charstring_st,
2504           new CharstringSubtypeTreeElement(CharRangeListConstraint(min_limit,max_limit), true));
2505         charstring_st->set_char_context(false);
2506       } else {
2507         // ignore it, error reported elsewhere
2508         return false;
2509       }
2510     }
2511   } break;
2512   case ST_UNIVERSAL_CHARSTRING: {
2513     if (((vmin!=NULL) && (vmin->get_valuetype()!=Value::V_USTR)) ||
2514         ((vmax!=NULL) && (vmax->get_valuetype()!=Value::V_USTR))) return false;
2515     if ((vmin==NULL)&&(vmax==NULL)) {
2516       my_owner->error("a range subtype of a universal charstring cannot be (-infinity..infinity)");
2517       return false;
2518     }
2519     if (vmin==NULL) {
2520       my_owner->error("lower boundary of a universal charstring subtype range cannot be -infinity");
2521       return false;
2522     }
2523     if (vmax==NULL) {
2524       my_owner->error("upper boundary of a universal charstring subtype range cannot be infinity");
2525       return false;
2526     }
2527     if (vmin->get_val_ustr().size()!=1) {
2528       min->error("lower boundary of universal charstring subtype range must be a single element string");
2529       return false;
2530     }
2531     if (vmax->get_val_ustr().size()!=1) {
2532       max->error("upper boundary of universal charstring subtype range must be a single element string");
2533       return false;
2534     }
2535     if (!universal_char_limit_t::is_valid_value(*vmin->get_val_ustr().u_str())) {
2536       min->error("lower boundary of universal charstring subtype range is an invalid char");
2537       return false;
2538     }
2539     if (!universal_char_limit_t::is_valid_value(*vmax->get_val_ustr().u_str())) {
2540       max->error("upper boundary of universal charstring subtype range is an invalid char");
2541       return false;
2542     }
2543     universal_char_limit_t min_limit(*vmin->get_val_ustr().u_str()), max_limit(*vmax->get_val_ustr().u_str());
2544     if (min_exclusive) {
2545       if (min_limit==universal_char_limit_t::maximum) {
2546         min->error("exclusive lower boundary is not a legal universal charstring character");
2547         return false;
2548       }
2549       min_limit = min_limit.next();
2550     }
2551     if (max_exclusive) {
2552       if (max_limit==universal_char_limit_t::minimum) {
2553         max->error("exclusive upper boundary is not a legal universal charstring character");
2554         return false;
2555       }
2556       max_limit = max_limit.previous();
2557     }
2558     if (max_limit<min_limit) {
2559       my_owner->error("lower boundary is bigger than upper boundary in universal charstring subtype range");
2560       return false;
2561     }
2562
2563     if (universal_charstring_st==NULL) universal_charstring_st = new UniversalCharstringSubtypeTreeElement(UniversalCharRangeListConstraint(min_limit,max_limit), false);
2564     else {
2565       if (!has_other) { // union in char context can be done only with range constraints
2566         universal_charstring_st->set_char_context(true);
2567         universal_charstring_st = new UniversalCharstringSubtypeTreeElement(UniversalCharstringSubtypeTreeElement::ET_UNION,
2568           universal_charstring_st,
2569           new UniversalCharstringSubtypeTreeElement(UniversalCharRangeListConstraint(min_limit,max_limit), true));
2570         universal_charstring_st->set_char_context(false);
2571       } else {
2572         // ignore it, error reported elsewhere
2573         return false;
2574       }
2575     }
2576   } break;
2577   default:
2578     FATAL_ERROR("SubType::add_ttcn_range()");
2579   }
2580   return true;
2581 }
2582
2583 bool SubType::set_ttcn_length(const size_limit_t& min, const size_limit_t& max)
2584 {
2585   switch (subtype) {
2586   case ST_BITSTRING: {
2587     if (bitstring_st==NULL) bitstring_st = new BitstringConstraint(min,max);
2588     else *bitstring_st = *bitstring_st * BitstringConstraint(min,max);
2589   } break;
2590   case ST_HEXSTRING: {
2591     if (hexstring_st==NULL) hexstring_st = new HexstringConstraint(min,max);
2592     else *hexstring_st = *hexstring_st * HexstringConstraint(min,max);
2593   } break;
2594   case ST_OCTETSTRING: {
2595     if (octetstring_st==NULL) octetstring_st = new OctetstringConstraint(min,max);
2596     else *octetstring_st = *octetstring_st * OctetstringConstraint(min,max);
2597   } break;
2598   case ST_CHARSTRING: {
2599     CharstringSubtypeTreeElement* cst_elem = new CharstringSubtypeTreeElement(SizeRangeListConstraint(min,max));
2600     if (charstring_st==NULL) {
2601       charstring_st = cst_elem;
2602     } else {
2603       charstring_st = new CharstringSubtypeTreeElement(CharstringSubtypeTreeElement::ET_INTERSECTION, charstring_st, cst_elem);
2604     }
2605   } break;
2606   case ST_UNIVERSAL_CHARSTRING: {
2607     UniversalCharstringSubtypeTreeElement* ucst_elem = new UniversalCharstringSubtypeTreeElement(SizeRangeListConstraint(min,max));
2608     if (universal_charstring_st==NULL) {
2609       universal_charstring_st = ucst_elem;
2610     } else {
2611       universal_charstring_st = new UniversalCharstringSubtypeTreeElement(UniversalCharstringSubtypeTreeElement::ET_INTERSECTION, universal_charstring_st, ucst_elem);
2612     }
2613   } break;
2614   case ST_RECORDOF:
2615   case ST_SETOF: {
2616     if (recof_st==NULL) recof_st = new RecofConstraint(min,max);
2617     else *recof_st = *recof_st * RecofConstraint(min,max);
2618   } break;
2619   default:
2620     my_owner->error("Length subtyping is not allowed for type `%s'",
2621                     my_owner->get_typename().c_str());
2622     return false;
2623   }
2624   if (length_restriction==NULL) length_restriction = new SizeRangeListConstraint(min,max);
2625   else *length_restriction = *length_restriction * SizeRangeListConstraint(min,max);
2626   return true;
2627 }
2628
2629 void SubType::chk_boundary_valid(Value* boundary, Int max_value, const char* boundary_name)
2630 {
2631   const int_val_t *int_val = boundary->get_val_Int();
2632   if (*int_val > int_val_t(max_value)) {
2633     boundary->error("The %s should be less than `%s' instead of `%s'",
2634       boundary_name,
2635       int_val_t(max_value).t_str().c_str(),
2636       int_val->t_str().c_str());
2637     boundary->set_valuetype(Value::V_ERROR);
2638   }
2639 }
2640
2641 bool SubType::add_ttcn_length(Ttcn::LengthRestriction *lr, size_t restriction_index)
2642 {
2643   string s;
2644   lr->append_stringRepr(s);
2645   Value *lower=NULL,*upper=NULL;
2646   lr->set_my_scope(my_owner->get_my_scope());
2647   lr->set_fullname(my_owner->get_fullname()+".<length_restriction_"+Int2string(restriction_index)+">");
2648   lr->chk(Type::EXPECTED_CONSTANT);
2649   lower = lr->get_is_range() ? lr->get_lower_value() : lr->get_single_value();
2650   if (!lower->get_my_scope()) FATAL_ERROR("no scope");
2651   if (lower->get_valuetype() != Value::V_INT) return false;
2652   if (lr->get_is_range()) {
2653     upper = lr->get_upper_value();
2654     if (upper) {//HAS_UPPER
2655       if (upper->get_valuetype()!=Value::V_INT) return false;
2656       if (!upper->get_my_scope()) upper->set_my_scope(my_owner->get_my_scope());
2657       chk_boundary_valid(upper, INT_MAX, "upper boundary");
2658       if (upper->get_valuetype()!=Value::V_INT) return false;
2659       return set_ttcn_length(size_limit_t((size_t)lower->get_val_Int()->get_val()),
2660                              size_limit_t((size_t)upper->get_val_Int()->get_val()));
2661     } else {//INFINITY:
2662       chk_boundary_valid(lower, INT_MAX, "lower boundary");
2663       if (lower->get_valuetype()!=Value::V_INT) return false;
2664       return set_ttcn_length(size_limit_t((size_t)lower->get_val_Int()->get_val()),
2665                              size_limit_t(size_limit_t::INFINITE_SIZE));
2666     }
2667   }
2668   else {//SINGLE:
2669     chk_boundary_valid(lower, INT_MAX, "length restriction value");
2670     if (lower->get_valuetype()!=Value::V_INT) return false;
2671     return set_ttcn_length(size_limit_t((size_t)lower->get_val_Int()->get_val()),
2672                            size_limit_t((size_t)lower->get_val_Int()->get_val()));
2673   }
2674 }
2675
2676 bool SubType::add_ttcn_pattern(Ttcn::PatternString* pattern, size_t restriction_index)
2677 {
2678   pattern->set_my_scope(my_owner->get_my_scope());
2679   pattern->set_fullname(my_owner->get_fullname()+".<pattern_restriction_"+Int2string(restriction_index) + ">");
2680   switch (subtype) {
2681   case ST_CHARSTRING: {
2682     Error_Context cntxt(my_owner, "In character string pattern");
2683     pattern->chk_refs(Type::EXPECTED_CONSTANT);
2684           pattern->join_strings();
2685         if (!pattern->has_refs()) { // if chk_refs didn't remove all references then ignore
2686       pattern->chk_pattern();
2687       CharstringSubtypeTreeElement* cst_elem = new CharstringSubtypeTreeElement(StringPatternConstraint(pattern));
2688       if (charstring_st==NULL) {
2689         charstring_st = cst_elem;
2690       } else {
2691         charstring_st = new CharstringSubtypeTreeElement(CharstringSubtypeTreeElement::ET_INTERSECTION, charstring_st, cst_elem);
2692       }
2693     }
2694   } break;
2695   case ST_UNIVERSAL_CHARSTRING: {
2696     Error_Context cntxt(my_owner, "In universal string pattern");
2697     pattern->set_pattern_type(Ttcn::PatternString::USTR_PATTERN);
2698     pattern->chk_refs(Type::EXPECTED_CONSTANT);
2699           pattern->join_strings();
2700         if (!pattern->has_refs()) { // if chk_refs didn't remove all references then ignore
2701       pattern->chk_pattern();
2702       UniversalCharstringSubtypeTreeElement* ucst_elem = new UniversalCharstringSubtypeTreeElement(StringPatternConstraint(pattern));
2703       if (universal_charstring_st==NULL) {
2704         universal_charstring_st = ucst_elem;
2705       } else {
2706         universal_charstring_st = new UniversalCharstringSubtypeTreeElement(UniversalCharstringSubtypeTreeElement::ET_INTERSECTION, universal_charstring_st, ucst_elem);
2707       }
2708     }
2709   } break;
2710   default:
2711     my_owner->error("Pattern subtyping of type `%s' is not allowed", my_owner->get_typename().c_str());
2712     return false;
2713   }
2714   return true;
2715 }
2716
2717 void SubType::print_full_warning() const
2718 {
2719   my_owner->warning("The subtype of type `%s' is a full set, "
2720     "it does not constrain the root type.", my_owner->get_typename().c_str());
2721 }
2722
2723 void SubType::chk()
2724 {
2725   if ((checked!=STC_NO) || (subtype==ST_ERROR)) FATAL_ERROR("SubType::chk()");
2726   checked = STC_CHECKING;
2727
2728   // check for circular subtype reference
2729   if (parent_subtype && !add_parent_subtype(parent_subtype)) {
2730     set_to_error();
2731     checked = STC_YES;
2732     return;
2733   }
2734
2735   if (parsed) { // has TTCN-3 subtype constraint
2736     size_t added_count = 0;
2737     bool has_single = false, has_range = false,
2738          has_length = false, has_pattern = false;
2739     for (size_t i = 0; i < parsed->size(); i++) {
2740       bool added = false;
2741       SubTypeParse *parse = (*parsed)[i];
2742       switch (parse->get_selection()) {
2743       case SubTypeParse::STP_SINGLE:
2744         has_single = true;
2745         added = add_ttcn_single(parse->Single(),i);
2746         break;
2747       case SubTypeParse::STP_RANGE:
2748         has_range = true;
2749         added = add_ttcn_range(parse->Min(), parse->MinExclusive(),
2750                                parse->Max(), parse->MaxExclusive(), i,
2751                                has_single || has_length || has_pattern);
2752         break;
2753       case SubTypeParse::STP_LENGTH:
2754         has_length = true;
2755         added = add_ttcn_length(parse->Length(),i);
2756         break;
2757       case SubTypeParse::STP_PATTERN:
2758         has_pattern = true;
2759         added = add_ttcn_pattern(parse->Pattern(),i);
2760         break;
2761       default:
2762         FATAL_ERROR("SubType::chk(): invalid SubTypeParse selection");
2763       } // switch
2764       if (added) added_count++;
2765     }//for
2766     switch (subtype) {
2767     case ST_CHARSTRING:
2768     case ST_UNIVERSAL_CHARSTRING:
2769       if (has_single && has_range) {
2770         my_owner->error(
2771           "Mixing of value list and range subtyping is not allowed for type `%s'",
2772           my_owner->get_typename().c_str());
2773         set_to_error();
2774         checked = STC_YES;
2775         return;
2776       }
2777       break;
2778     default:
2779       // in other cases mixing of different restrictions (which are legal for
2780       // this type) is properly regulated by the TTCN-3 BNF itself
2781       break;
2782     }
2783     if (added_count<parsed->size()) {
2784       set_to_error();
2785       checked = STC_YES;
2786       return;
2787     }
2788     if (subtype==ST_ERROR) { checked = STC_YES; return; }
2789
2790     if (parent_subtype) {
2791       if (is_subset(parent_subtype->get_root())==TFALSE) {
2792         my_owner->error("The subtype restriction is not a subset of the restriction on the parent type. "
2793           "Subtype %s is not subset of subtype %s", to_string().c_str(), parent_subtype->get_root()->to_string().c_str());
2794         set_to_error();
2795         checked = STC_YES;
2796         return;
2797       }
2798       intersection(parent_subtype->get_root());
2799     }
2800   } else if (asn_constraints) { // has ASN.1 subtype constraint
2801     SubtypeConstraint* asn_parent_subtype = NULL;
2802     if (parent_subtype) {
2803       // the type constraint of the ASN.1 type is already in the parent_subtype,
2804       // don't add it multiple times
2805       asn_parent_subtype = parent_subtype->get_root();
2806     } else {
2807       asn_parent_subtype = get_asn_type_constraint(my_owner);
2808     }
2809     asn_constraints->chk(asn_parent_subtype);
2810     root = asn_constraints->get_subtype();
2811     extendable = asn_constraints->is_extendable();
2812     extension  = asn_constraints->get_extension();
2813     // the TTCN-3 subtype will be the union of the root and extension parts
2814     // the ETSI ES 201 873-7 V4.1.2 (2009-07) document says to "ignore any extension markers"
2815     // but titan now works this way :)
2816     if (root) copy(root);
2817     if (extension) union_(extension);
2818   } else { // no constraints on this type -> this is an alias type, just copy the subtype from the other
2819     if (parent_subtype) {
2820       root = parent_subtype->root;
2821       extendable = parent_subtype->extendable;
2822       extension = parent_subtype->extension;
2823       copy(parent_subtype);
2824     } else {
2825       SubtypeConstraint* asn_parent_subtype = get_asn_type_constraint(my_owner);
2826       if (asn_parent_subtype) copy(asn_parent_subtype);
2827     }
2828   }
2829
2830   // check if subtype is valid: it must not be an empty set (is_empty==TTRUE)
2831   // issue warning if subtype is given but is full set (is_full==TTRUE)
2832   // ignore cases of TUNKNOWN when compiler can't figure out if the aggregate
2833   // set is empty or full
2834   switch (subtype) {
2835   case ST_INTEGER:
2836     if (integer_st!=NULL) {
2837       if (integer_st->is_empty()==TTRUE) goto empty_error;
2838       if (integer_st->is_full()==TTRUE) {
2839         print_full_warning();
2840         delete integer_st;
2841         integer_st = NULL;
2842       }
2843     }
2844     break;
2845   case ST_FLOAT:
2846     if (float_st!=NULL) {
2847       if (float_st->is_empty()==TTRUE) goto empty_error;
2848       if (float_st->is_full()==TTRUE) {
2849         print_full_warning();
2850         delete float_st;
2851         float_st = NULL;
2852       }
2853     }
2854     break;
2855   case ST_BOOLEAN:
2856     if (boolean_st!=NULL) {
2857       if (boolean_st->is_empty()==TTRUE) goto empty_error;
2858       if (boolean_st->is_full()==TTRUE) {
2859         print_full_warning();
2860         delete boolean_st;
2861         boolean_st = NULL;
2862       }
2863     }
2864     break;
2865   case ST_VERDICTTYPE:
2866     if (verdict_st!=NULL) {
2867       if (verdict_st->is_empty()==TTRUE) goto empty_error;
2868       if (verdict_st->is_full()==TTRUE) {
2869         print_full_warning();
2870         delete verdict_st;
2871         verdict_st = NULL;
2872       }
2873     }
2874     break;
2875   case ST_BITSTRING:
2876     if (bitstring_st!=NULL) {
2877       if (bitstring_st->is_empty()==TTRUE) goto empty_error;
2878       if (bitstring_st->is_full()==TTRUE) {
2879         print_full_warning();
2880         delete bitstring_st;
2881         bitstring_st = NULL;
2882       }
2883     }
2884     break;
2885   case ST_HEXSTRING:
2886     if (hexstring_st!=NULL) {
2887       if (hexstring_st->is_empty()==TTRUE) goto empty_error;
2888       if (hexstring_st->is_full()==TTRUE) {
2889         print_full_warning();
2890         delete hexstring_st;
2891         hexstring_st = NULL;
2892       }
2893     }
2894     break;
2895   case ST_OCTETSTRING:
2896     if (octetstring_st!=NULL) {
2897       if (octetstring_st->is_empty()==TTRUE) goto empty_error;
2898       if (octetstring_st->is_full()==TTRUE) {
2899         print_full_warning();
2900         delete octetstring_st;
2901         octetstring_st = NULL;
2902       }
2903     }
2904     break;
2905   case ST_CHARSTRING:
2906     if (charstring_st!=NULL) {
2907       if (charstring_st->is_empty()==TTRUE) goto empty_error;
2908       if (charstring_st->is_full()==TTRUE) {
2909         print_full_warning();
2910         delete charstring_st;
2911         charstring_st = NULL;
2912       }
2913     }
2914     break;
2915   case ST_UNIVERSAL_CHARSTRING:
2916     if (universal_charstring_st!=NULL) {
2917       if (universal_charstring_st->is_empty()==TTRUE) goto empty_error;
2918       if (universal_charstring_st->is_full()==TTRUE) {
2919         print_full_warning();
2920         delete universal_charstring_st;
2921         universal_charstring_st = NULL;
2922       }
2923     }
2924     break;
2925   case ST_OBJID:
2926   case ST_RECORD:
2927   case ST_SET:
2928   case ST_ENUM:
2929   case ST_UNION:
2930   case ST_FUNCTION:
2931   case ST_ALTSTEP:
2932   case ST_TESTCASE:
2933     if (value_st!=NULL) {
2934       if (value_st->is_empty()==TTRUE) goto empty_error;
2935       if (value_st->is_full()==TTRUE) {
2936         print_full_warning();
2937         delete value_st;
2938         value_st = NULL;
2939       }
2940     }
2941     break;
2942   case ST_RECORDOF:
2943   case ST_SETOF:
2944     if (recof_st!=NULL) {
2945       if (recof_st->is_empty()==TTRUE) goto empty_error;
2946       if (recof_st->is_full()==TTRUE) {
2947         print_full_warning();
2948         delete recof_st;
2949         recof_st = NULL;
2950       }
2951     }
2952     break;
2953   default:
2954     FATAL_ERROR("SubType::chk()");
2955   }
2956   if ((length_restriction!=NULL) && (length_restriction->is_full()==TTRUE)) {
2957     delete length_restriction;
2958     length_restriction = NULL;
2959   }
2960   checked = STC_YES;
2961   return;
2962
2963 empty_error:
2964   my_owner->error("The subtype is an empty set");
2965   set_to_error();
2966   checked = STC_YES;
2967   return;
2968 }
2969
2970 void SubType::dump(unsigned level) const
2971 {
2972   string str = to_string();
2973   if (str.size()>0) DEBUG(level, "restriction(s): %s", str.c_str());
2974 }
2975
2976 Int SubType::get_length_restriction() const
2977 {
2978   if (checked!=STC_YES) FATAL_ERROR("SubType::get_length_restriction()");
2979   if (parsed==NULL) return -1; // only own length restriction counts
2980   if (length_restriction==NULL) return -1;
2981   if (length_restriction->is_empty()) return -1;
2982   return ( (length_restriction->get_minimal()==length_restriction->get_maximal()) ?
2983            (Int)(length_restriction->get_minimal().get_size()) :
2984            -1 );
2985 }
2986
2987 bool SubType::zero_length_allowed() const
2988 {
2989   if (checked!=STC_YES) FATAL_ERROR("SubType::zero_length_allowed()");
2990   if (parsed==NULL) return true; // only own length restriction counts
2991   if (length_restriction==NULL) return true;
2992   return length_restriction->is_element(size_limit_t(0));
2993 }
2994
2995 string SubType::to_string() const
2996 {
2997   if (root) {
2998     string ret_val(root->to_string());
2999     if (extendable) ret_val += ", ...";
3000     if (extension) {
3001       ret_val += ", ";
3002       ret_val += extension->to_string();
3003     }
3004     return ret_val;
3005   }
3006   return SubtypeConstraint::to_string();
3007 }
3008
3009 ////////////////////////////////////////////////////////////////////////////////
3010
3011 void SubType::generate_code(output_struct &)
3012 {
3013   if (checked!=STC_YES) FATAL_ERROR("SubType::generate_code()");
3014 }
3015
3016 } // namespace Common