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