compiler2/ttcn3/TtcnTemplate.cc

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Copyright (c) 2000-2015 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 "TtcnTemplate.hh"
   9 #include "../Identifier.hh"
  10 #include "Templatestuff.hh"
  11 #include "../Type.hh"
  12 #include "../TypeCompat.hh"
  13 #include "../SigParam.hh"
  14 #include "../CompField.hh"
  15 #include "../Valuestuff.hh"
  16 #include "ArrayDimensions.hh"
  17 #include "PatternString.hh"
  18 #include "../main.hh"
  19 #include "../../common/dbgnew.hh"
  20 #include "Attributes.hh"
  21
  22 namespace Ttcn {
  23
  24   // =================================
  25   // ===== Template
  26   // =================================
  27
  28   Template::Template(const Template& p) : GovernedSimple(p),
  29     templatetype(p.templatetype), my_governor(p.my_governor),
  30     is_ifpresent(p.is_ifpresent), specific_value_checked(false),
  31     has_permutation(p.has_permutation), base_template(p.base_template)
  32   {
  33     switch (templatetype) {
  34     case TEMPLATE_ERROR:
  35     case TEMPLATE_NOTUSED:
  36     case OMIT_VALUE:
  37     case ANY_VALUE:
  38     case ANY_OR_OMIT:
  39       break;
  40     case SPECIFIC_VALUE:
  41       u.specific_value = p.u.specific_value->clone();
  42       break;
  43     case TEMPLATE_REFD:
  44       u.ref.ref = p.u.ref.ref->clone();
  45       u.ref.refd = 0;
  46       u.ref.refd_last = 0;
  47       break;
  48     case TEMPLATE_INVOKE:
  49       u.invoke.v = p.u.invoke.v->clone();
  50       u.invoke.t_list = p.u.invoke.t_list ? p.u.invoke.t_list->clone() : 0;
  51       u.invoke.ap_list = p.u.invoke.ap_list ? p.u.invoke.ap_list->clone() : 0;
  52       break;
  53     case ALL_FROM:
  54     case VALUE_LIST_ALL_FROM:
  55       u.all_from = p.u.all_from->clone();
  56       break;
  57     case TEMPLATE_LIST:
  58     case VALUE_LIST:
  59     case COMPLEMENTED_LIST:
  60     case SUPERSET_MATCH:
  61     case SUBSET_MATCH:
  62     case PERMUTATION_MATCH:
  63       u.templates = p.u.templates->clone(); // FATAL_ERROR
  64       break;
  65     case NAMED_TEMPLATE_LIST:
  66       u.named_templates = p.u.named_templates->clone(); // FATAL_ERROR
  67       break;
  68     case INDEXED_TEMPLATE_LIST:
  69       u.indexed_templates = p.u.indexed_templates->clone(); // FATAL_ERROR
  70       break;
  71     case VALUE_RANGE:
  72       u.value_range = p.u.value_range->clone();
  73       break;
  74     case BSTR_PATTERN:
  75     case HSTR_PATTERN:
  76     case OSTR_PATTERN:
  77       u.pattern = new string(*p.u.pattern);
  78       break;
  79     case CSTR_PATTERN:
  80     case USTR_PATTERN:
  81       u.pstring = p.u.pstring->clone();
  82       break;
  83 //    default:
  84 //      FATAL_ERROR("Template::Template()");
  85     }
  86     length_restriction =
  87       p.length_restriction ? p.length_restriction->clone() : 0; // FATAL_ERR
  88   }
  89
  90   void Template::clean_up()
  91   {
  92     switch(templatetype) {
  93     case TEMPLATE_ERROR:
  94     case TEMPLATE_NOTUSED:
  95     case OMIT_VALUE:
  96     case ANY_VALUE:
  97     case ANY_OR_OMIT:
  98       break;
  99     case SPECIFIC_VALUE:
 100       delete u.specific_value;
 101       break;
 102     case TEMPLATE_REFD:
 103       delete u.ref.ref;
 104       break;
 105     case TEMPLATE_INVOKE:
 106       delete u.invoke.v;
 107       delete u.invoke.t_list;
 108       delete u.invoke.ap_list;
 109       break;
 110     case TEMPLATE_LIST:
 111     case VALUE_LIST:
 112     case COMPLEMENTED_LIST:
 113     case SUPERSET_MATCH:
 114     case SUBSET_MATCH:
 115     case PERMUTATION_MATCH:
 116       delete u.templates;
 117       break;
 118     case ALL_FROM:
 119     case VALUE_LIST_ALL_FROM:
 120       delete u.all_from;
 121       break;
 122     case NAMED_TEMPLATE_LIST:
 123       delete u.named_templates;
 124       break;
 125     case INDEXED_TEMPLATE_LIST:
 126       delete u.indexed_templates;
 127       break;
 128     case VALUE_RANGE:
 129       delete u.value_range;
 130       break;
 131     case BSTR_PATTERN:
 132     case HSTR_PATTERN:
 133     case OSTR_PATTERN:
 134       delete u.pattern;
 135       break;
 136     case CSTR_PATTERN:
 137     case USTR_PATTERN:
 138       delete u.pstring;
 139       break;
 140 //    default:
 141 //      FATAL_ERROR("Template::clean_up()");
 142     }
 143   }
 144
 145   string Template::create_stringRepr()
 146   {
 147     string ret_val;
 148     switch (templatetype) {
 149     case TEMPLATE_ERROR:
 150       ret_val += "<erroneous template>";
 151       break;
 152     case TEMPLATE_NOTUSED:
 153       ret_val += "-";
 154       break;
 155     case OMIT_VALUE:
 156       ret_val += "omit";
 157       break;
 158     case ANY_VALUE:
 159       ret_val += "?";
 160       break;
 161     case ANY_OR_OMIT:
 162       ret_val += "*";
 163       break;
 164     case SPECIFIC_VALUE:
 165       ret_val += u.specific_value->get_stringRepr();
 166       break;
 167     case TEMPLATE_REFD: {
 168       Template *t_last = get_template_refd_last();
 169       if (t_last->templatetype == TEMPLATE_REFD)
 170         ret_val += u.ref.ref->get_dispname();
 171       else ret_val += t_last->get_stringRepr();
 172       break; }
 173     case TEMPLATE_INVOKE: {
 174       ret_val += u.invoke.v->get_stringRepr();
 175       ret_val += ".invoke(";
 176       if(u.invoke.ap_list)
 177         for(size_t i = 0; i < u.invoke.ap_list->get_nof_pars(); i++) {
 178           if(i>0) ret_val += ", ";
 179           ret_val += u.invoke.ap_list->get_par(i)->get_fullname();
 180         }
 181       ret_val += ")";
 182       break; }
 183     case TEMPLATE_LIST:
 184       if (u.templates->get_nof_ts() > 0) {
 185         ret_val += "{ ";
 186         u.templates->append_stringRepr(ret_val);
 187         ret_val += " }";
 188       } else ret_val += "{ }";
 189       break;
 190     case NAMED_TEMPLATE_LIST:
 191       ret_val += "{";
 192       for (size_t i = 0; i < u.named_templates->get_nof_nts(); i++) {
 193         if (i > 0) ret_val += ", ";
 194         else ret_val += " ";
 195         NamedTemplate *nt = u.named_templates->get_nt_byIndex(i);
 196         ret_val += nt->get_name().get_dispname();
 197         ret_val += " := ";
 198         ret_val += nt->get_template()->get_stringRepr();
 199       }
 200       ret_val += " }";
 201       break;
 202     case INDEXED_TEMPLATE_LIST:
 203       ret_val += "{";
 204       for (size_t i = 0; i < u.indexed_templates->get_nof_its(); i++) {
 205         if (i > 0) ret_val += ", ";
 206         else ret_val += " [";
 207         IndexedTemplate *it = u.indexed_templates->get_it_byIndex(i);
 208         (it->get_index()).append_stringRepr(ret_val);
 209         ret_val += "] := ";
 210         ret_val += it->get_template()->get_stringRepr();
 211       }
 212       ret_val += "}";
 213       break;
 214     case VALUE_LIST:
 215       ret_val += "(";
 216       u.templates->append_stringRepr(ret_val);
 217       ret_val += ")";
 218       break;
 219     case COMPLEMENTED_LIST:
 220       ret_val += "complement(";
 221       u.templates->append_stringRepr(ret_val);
 222       ret_val += ")";
 223       break;
 224     case VALUE_RANGE:
 225       u.value_range->append_stringRepr(ret_val);
 226       break;
 227     case SUPERSET_MATCH:
 228       ret_val += "superset(";
 229       u.templates->append_stringRepr(ret_val);
 230       ret_val += ")";
 231       break;
 232     case SUBSET_MATCH:
 233       ret_val += "subset(";
 234       u.templates->append_stringRepr(ret_val);
 235       ret_val += ")";
 236       break;
 237     case PERMUTATION_MATCH:
 238       ret_val += "permutation(";
 239       u.templates->append_stringRepr(ret_val);
 240       ret_val += ")";
 241       break;
 242     case BSTR_PATTERN:
 243       ret_val += "'";
 244       ret_val += *u.pattern;
 245       ret_val += "'B";
 246       break;
 247     case HSTR_PATTERN:
 248       ret_val += "'";
 249       ret_val += *u.pattern;
 250       ret_val += "'H";
 251       break;
 252     case OSTR_PATTERN:
 253       ret_val += "'";
 254       ret_val += *u.pattern;
 255       ret_val += "'O";
 256       break;
 257     case CSTR_PATTERN:
 258     case USTR_PATTERN:
 259       ret_val += "pattern \"";
 260       ret_val += u.pstring->get_full_str();
 261       ret_val += "\"";
 262       break;
 263     default:
 264       ret_val += "<unknown template>";
 265       break;
 266     }
 267     if (length_restriction) length_restriction->append_stringRepr(ret_val);
 268     if (is_ifpresent) ret_val += " ifpresent";
 269     return ret_val;
 270   }
 271
 272   Template::Template(templatetype_t tt)
 273     : GovernedSimple(S_TEMPLATE),
 274       templatetype(tt), my_governor(0), length_restriction(0),
 275       is_ifpresent(false), specific_value_checked(false),
 276       has_permutation(false), flattened(true), base_template(0)
 277   {
 278     switch (tt) {
 279     case TEMPLATE_ERROR:
 280     case TEMPLATE_NOTUSED:
 281     case OMIT_VALUE:
 282     case ANY_VALUE:
 283     case ANY_OR_OMIT:
 284       break;
 285     default:
 286       FATAL_ERROR("Template::Template()");
 287     }
 288   }
 289
 290   Template::Template(Value *v)
 291     : GovernedSimple(S_TEMPLATE),
 292       templatetype(SPECIFIC_VALUE), my_governor(0), length_restriction(0),
 293       is_ifpresent(false), specific_value_checked(false),
 294       has_permutation(false), flattened(true), base_template(0)
 295   {
 296     if (!v) FATAL_ERROR("Template::Template()");
 297     u.specific_value = v;
 298   }
 299
 300   Template::Template(Ref_base *p_ref)
 301     : GovernedSimple(S_TEMPLATE),
 302       templatetype(TEMPLATE_REFD), my_governor(0), length_restriction(0),
 303       is_ifpresent(false), specific_value_checked(false),
 304       has_permutation(false), base_template(0)
 305   {
 306     if(!p_ref) FATAL_ERROR("Template::Template()");
 307     u.ref.ref=p_ref;
 308     u.ref.refd=0;
 309     u.ref.refd_last=0;
 310   }
 311
 312   Template::Template(templatetype_t tt, Templates *ts)
 313     : GovernedSimple(S_TEMPLATE),
 314       templatetype(tt), my_governor(0), length_restriction(0),
 315       is_ifpresent(false), specific_value_checked(false),
 316       has_permutation(false), flattened(true), base_template(0)
 317   {
 318     switch (tt) {
 319     case TEMPLATE_LIST:
 320     case VALUE_LIST:
 321     case COMPLEMENTED_LIST:
 322     case SUPERSET_MATCH:
 323     case SUBSET_MATCH:
 324     case PERMUTATION_MATCH:
 325       break;
 326     default:
 327       FATAL_ERROR("Template::Template()");
 328     }
 329     if (!ts) FATAL_ERROR("Template::Template()");
 330     u.templates = ts;
 331     if (tt == TEMPLATE_LIST) {
 332       size_t nof_ts = ts->get_nof_ts();
 333       for (size_t i = 0; i < nof_ts; i++) {
 334         if (ts->get_t_byIndex(i)->templatetype == PERMUTATION_MATCH) {
 335           has_permutation = true;
 336           break;
 337         }
 338       }
 339     }
 340   }
 341
 342   Template::Template(Template *t)
 343   : GovernedSimple(S_TEMPLATE)
 344   , templatetype(ALL_FROM), my_governor(0), length_restriction(0)
 345   , is_ifpresent(false), specific_value_checked(false)
 346   , has_permutation(false), flattened(true), base_template(0)
 347   {
 348     u.all_from = t;
 349     // t is usually a SPECIFIC_VALUE
 350     // t->u.specific_value is a V_UNDEF_LOWERID
 351     // calling set_lowerid_to_ref is too soon (my_scope is not set yet)
 352   }
 353
 354   Template::Template(templatetype_t tt, Template *t)
 355   : GovernedSimple(S_TEMPLATE)
 356   , templatetype(VALUE_LIST_ALL_FROM), my_governor(0), length_restriction(0)
 357   , is_ifpresent(false), specific_value_checked(false)
 358   , has_permutation(false), flattened(true), base_template(0)
 359   {
 360     if (tt != VALUE_LIST_ALL_FROM) FATAL_ERROR("Template::Template()");
 361     u.all_from = t->u.all_from; // take it over
 362     t->u.all_from = NULL;
 363     delete t;
 364   }
 365
 366   Template::Template(NamedTemplates *nts)
 367     : GovernedSimple(S_TEMPLATE),
 368       templatetype(NAMED_TEMPLATE_LIST), my_governor(0), length_restriction(0),
 369       is_ifpresent(false), specific_value_checked(false),
 370       has_permutation(false), flattened(true), base_template(0)
 371   {
 372     if (!nts) FATAL_ERROR("Template::Template()");
 373     u.named_templates = nts;
 374   }
 375
 376   Template::Template(IndexedTemplates *its)
 377     : GovernedSimple(S_TEMPLATE),
 378       templatetype(INDEXED_TEMPLATE_LIST), my_governor(0),
 379       length_restriction(0), is_ifpresent(false),
 380       specific_value_checked(false), has_permutation(false), flattened(true),
 381       base_template(0)
 382   {
 383     if (!its) FATAL_ERROR("Template::Template()");
 384     u.indexed_templates = its;
 385     size_t nof_its = its->get_nof_its();
 386     for (size_t i = 0; i < nof_its; i++) {
 387       if (its->get_it_byIndex(i)->get_template()->templatetype ==
 388         PERMUTATION_MATCH) {
 389         has_permutation = true;
 390         break;
 391       }
 392     }
 393   }
 394
 395   Template::Template(ValueRange *vr)
 396     : GovernedSimple(S_TEMPLATE),
 397       templatetype(VALUE_RANGE), my_governor(0), length_restriction(0),
 398       is_ifpresent(false), specific_value_checked(false),
 399       has_permutation(false), flattened(true), base_template(0)
 400   {
 401     if (!vr) FATAL_ERROR("Template::Template()");
 402     u.value_range = vr;
 403   }
 404
 405   Template::Template(templatetype_t tt, string *p_patt)
 406     : GovernedSimple(S_TEMPLATE),
 407       templatetype(tt), my_governor(0), length_restriction(0),
 408       is_ifpresent(false), specific_value_checked(false),
 409       has_permutation(false), flattened(true), base_template(0)
 410   {
 411     switch (tt) {
 412     case BSTR_PATTERN:
 413     case HSTR_PATTERN:
 414     case OSTR_PATTERN:
 415       break;
 416     default:
 417       FATAL_ERROR("Template::Template()");
 418     }
 419     if (!p_patt) FATAL_ERROR("Template::Template()");
 420     u.pattern = p_patt;
 421   }
 422
 423   Template::Template(PatternString *p_ps)
 424     : GovernedSimple(S_TEMPLATE),
 425       templatetype(CSTR_PATTERN), my_governor(0), length_restriction(0),
 426       is_ifpresent(false), specific_value_checked(false),
 427       has_permutation(false), flattened(true), base_template(0)
 428   {
 429     if (!p_ps) FATAL_ERROR("Template::Template()");
 430     u.pstring = p_ps;
 431   }
 432
 433   Template::~Template()
 434   {
 435     clean_up();
 436     delete length_restriction;
 437   }
 438
 439   Template *Template::clone() const
 440   {
 441     return new Template(*this);
 442   }
 443
 444   void Template::set_fullname(const string& p_fullname)
 445   {
 446     GovernedSimple::set_fullname(p_fullname);
 447     switch (templatetype) {
 448     case TEMPLATE_ERROR:
 449     case TEMPLATE_NOTUSED:
 450     case OMIT_VALUE:
 451     case ANY_VALUE:
 452     case ANY_OR_OMIT:
 453     case BSTR_PATTERN:
 454     case HSTR_PATTERN:
 455     case OSTR_PATTERN:
 456       break;
 457     case SPECIFIC_VALUE:
 458       u.specific_value->set_fullname(p_fullname);
 459       break;
 460     case TEMPLATE_REFD:
 461       u.ref.ref->set_fullname(p_fullname);
 462       break;
 463     case TEMPLATE_INVOKE:
 464       u.invoke.v->set_fullname(p_fullname);
 465       if(u.invoke.t_list) u.invoke.t_list->set_fullname(p_fullname);
 466       if(u.invoke.ap_list) u.invoke.ap_list->set_fullname(p_fullname);
 467       break;
 468     case TEMPLATE_LIST:
 469       u.templates->set_fullname(p_fullname);
 470       for (size_t i = 0; i < u.templates->get_nof_ts(); i++)
 471         u.templates->get_t_byIndex(i)->set_fullname(
 472           p_fullname + "[" + Int2string(i) + "]");
 473       break;
 474     case INDEXED_TEMPLATE_LIST:
 475       u.indexed_templates->set_fullname(p_fullname);
 476       for (size_t i = 0; i < u.indexed_templates->get_nof_its(); i++)
 477         u.indexed_templates->get_it_byIndex(i)->set_fullname(
 478           p_fullname + "[" + Int2string(i) + "]");
 479       break;
 480     case NAMED_TEMPLATE_LIST:
 481       u.named_templates->set_fullname(p_fullname);
 482       break;
 483     case ALL_FROM:
 484     case VALUE_LIST_ALL_FROM:
 485       u.all_from->set_fullname(p_fullname);
 486       break;
 487     case VALUE_LIST:
 488     case COMPLEMENTED_LIST:
 489     case SUPERSET_MATCH:
 490     case SUBSET_MATCH:
 491     case PERMUTATION_MATCH:
 492       u.templates->set_fullname(p_fullname);
 493       for (size_t i = 0; i < u.templates->get_nof_ts(); i++)
 494         u.templates->get_t_byIndex(i)->set_fullname(
 495           p_fullname + ".list_item(" + Int2string(i) + ")");
 496       break;
 497     case VALUE_RANGE:
 498       u.value_range->set_fullname(p_fullname);
 499       break;
 500     case CSTR_PATTERN:
 501     case USTR_PATTERN:
 502       u.pstring->set_fullname(p_fullname);
 503       break;
 504 //    default:
 505 //      FATAL_ERROR("Template::set_fullname()");
 506     }
 507     if (length_restriction)
 508       length_restriction->set_fullname(p_fullname + ".<length_restriction>");
 509   }
 510
 511   void Template::set_my_scope(Scope *p_scope)
 512   {
 513     GovernedSimple::set_my_scope(p_scope);
 514     switch (templatetype) {
 515     case TEMPLATE_ERROR:
 516     case TEMPLATE_NOTUSED:
 517     case OMIT_VALUE:
 518     case ANY_VALUE:
 519     case ANY_OR_OMIT:
 520     case BSTR_PATTERN:
 521     case HSTR_PATTERN:
 522     case OSTR_PATTERN:
 523       break;
 524     case SPECIFIC_VALUE:
 525       u.specific_value->set_my_scope(p_scope);
 526       break;
 527     case TEMPLATE_REFD:
 528       u.ref.ref->set_my_scope(p_scope);
 529       break;
 530     case TEMPLATE_INVOKE:
 531       u.invoke.v->set_my_scope(p_scope);
 532       if(u.invoke.t_list) u.invoke.t_list->set_my_scope(p_scope);
 533       if(u.invoke.ap_list) u.invoke.ap_list->set_my_scope(p_scope);
 534       break;
 535     case ALL_FROM:
 536     case VALUE_LIST_ALL_FROM:
 537       u.all_from->set_my_scope(p_scope);
 538       break;
 539     case TEMPLATE_LIST:
 540     case VALUE_LIST:
 541     case COMPLEMENTED_LIST:
 542     case SUPERSET_MATCH:
 543     case SUBSET_MATCH:
 544     case PERMUTATION_MATCH:
 545       u.templates->set_my_scope(p_scope);
 546       break;
 547     case NAMED_TEMPLATE_LIST:
 548       u.named_templates->set_my_scope(p_scope);
 549       break;
 550     case INDEXED_TEMPLATE_LIST:
 551       u.indexed_templates->set_my_scope(p_scope);
 552       break;
 553     case VALUE_RANGE:
 554       u.value_range->set_my_scope(p_scope);
 555       break;
 556     case CSTR_PATTERN:
 557     case USTR_PATTERN:
 558       u.pstring->set_my_scope(p_scope);
 559       break;
 560 //    default:
 561 //      FATAL_ERROR("Template::set_my_scope()");
 562     }
 563     if (length_restriction) length_restriction->set_my_scope(p_scope);
 564   }
 565
 566   void Template::set_genname_recursive(const string& p_genname)
 567   {
 568     set_genname(p_genname);
 569     switch (templatetype) {
 570     case TEMPLATE_LIST: {
 571       if (!my_governor) return; // error recovery
 572       Type *type = my_governor->get_type_refd_last();
 573       Int offset;
 574       if (type->get_typetype() == Type::T_ARRAY)
 575         offset = type->get_dimension()->get_offset();
 576       else offset = 0;
 577       size_t nof_ts = u.templates->get_nof_ts();
 578       for (size_t i = 0; i < nof_ts; i++) {
 579         string embedded_genname(p_genname);
 580         embedded_genname += '[';
 581         embedded_genname += Int2string(offset + i);
 582         embedded_genname += ']';
 583         u.templates->get_t_byIndex(i)->set_genname_recursive(embedded_genname);
 584       }
 585       break; }
 586     case NAMED_TEMPLATE_LIST: {
 587       if (!my_governor) return; // error recovery
 588       Type *type = my_governor->get_type_refd_last();
 589       size_t nof_nts = u.named_templates->get_nof_nts();
 590       for (size_t i = 0; i < nof_nts; i++) {
 591         NamedTemplate *nt = u.named_templates->get_nt_byIndex(i);
 592         string embedded_genname(p_genname);
 593         embedded_genname += '.';
 594         if (type->get_typetype() == Type::T_ANYTYPE)
 595           embedded_genname += "AT_";
 596         embedded_genname += nt->get_name().get_name();
 597         embedded_genname += "()";
 598         nt->get_template()->set_genname_recursive(embedded_genname);
 599       }
 600       break; }
 601     default:
 602       break;
 603     }
 604   }
 605
 606   void Template::set_genname_prefix(const char *p_genname_prefix)
 607   {
 608     GovernedSimple::set_genname_prefix(p_genname_prefix);
 609     switch (templatetype) {
 610     case TEMPLATE_LIST:
 611       for (size_t i = 0; i < u.templates->get_nof_ts(); i++)
 612         u.templates->get_t_byIndex(i)->set_genname_prefix(p_genname_prefix);
 613       break;
 614     case NAMED_TEMPLATE_LIST:
 615       for (size_t i = 0; i < u.named_templates->get_nof_nts(); i++)
 616         u.named_templates->get_nt_byIndex(i)->get_template()
 617           ->set_genname_prefix(p_genname_prefix);
 618       break;
 619     case INDEXED_TEMPLATE_LIST:
 620       for (size_t i = 0; i < u.indexed_templates->get_nof_its(); i++)
 621         u.indexed_templates->get_it_byIndex(i)->get_template()
 622           ->set_genname_prefix(p_genname_prefix);
 623       break;
 624     default:
 625       break;
 626     }
 627   }
 628
 629   void Template::set_code_section(code_section_t p_code_section)
 630   {
 631     GovernedSimple::set_code_section(p_code_section);
 632     switch (templatetype) {
 633     case SPECIFIC_VALUE:
 634       u.specific_value->set_code_section(p_code_section);
 635       break;
 636     case TEMPLATE_REFD:
 637       u.ref.ref->set_code_section(p_code_section);
 638       break;
 639     case TEMPLATE_INVOKE:
 640       u.invoke.v->set_code_section(p_code_section);
 641       if(u.invoke.t_list) u.invoke.t_list->set_code_section(p_code_section);
 642       if(u.invoke.ap_list)
 643         for(size_t i = 0; i < u.invoke.ap_list->get_nof_pars(); i++)
 644             u.invoke.ap_list->get_par(i)->set_code_section(p_code_section);
 645       break;
 646     case TEMPLATE_LIST:
 647     case VALUE_LIST:
 648     case COMPLEMENTED_LIST:
 649     case SUPERSET_MATCH:
 650     case SUBSET_MATCH:
 651     case PERMUTATION_MATCH:
 652       for (size_t i = 0; i < u.templates->get_nof_ts(); i++)
 653         u.templates->get_t_byIndex(i)->set_code_section(p_code_section);
 654       break;
 655     case NAMED_TEMPLATE_LIST:
 656       for (size_t i = 0; i < u.named_templates->get_nof_nts(); i++)
 657         u.named_templates->get_nt_byIndex(i)->get_template()
 658           ->set_code_section(p_code_section);
 659       break;
 660     case INDEXED_TEMPLATE_LIST:
 661       for (size_t i = 0; i <u.indexed_templates->get_nof_its(); i++)
 662         u.indexed_templates->get_it_byIndex(i)
 663           ->set_code_section(p_code_section);
 664       break;
 665     case VALUE_RANGE:
 666       u.value_range->set_code_section(p_code_section);
 667       break;
 668     case CSTR_PATTERN:
 669     case USTR_PATTERN:
 670       u.pstring->set_code_section(p_code_section);
 671       break;
 672     default:
 673       break;
 674     }
 675     if (length_restriction)
 676       length_restriction->set_code_section(p_code_section);
 677   }
 678
 679   void Template::set_templatetype(templatetype_t p_templatetype)
 680   {
 681     if (p_templatetype == templatetype) return;
 682     if (p_templatetype == TEMPLATE_ERROR) {
 683       clean_up();
 684       templatetype = TEMPLATE_ERROR;
 685       return;
 686     }
 687     switch (templatetype) {
 688     case SPECIFIC_VALUE: // current type
 689       switch(p_templatetype) {
 690       case TEMPLATE_REFD: {
 691         Value *v = u.specific_value;
 692         u.ref.ref = v->steal_ttcn_ref_base();
 693         u.ref.refd = 0;
 694         u.ref.refd_last = 0;
 695         delete v;
 696         break; }
 697       case TEMPLATE_INVOKE: {
 698         Value *v = u.specific_value;
 699         v->steal_invoke_data(u.invoke.v, u.invoke.t_list, u.invoke.ap_list);
 700         delete v;
 701         break; }
 702       default:
 703         FATAL_ERROR("Template::set_templatetype()");
 704       }
 705       break;
 706     case TEMPLATE_LIST: // current type
 707       if (p_templatetype == NAMED_TEMPLATE_LIST) {
 708         // TEMPLATE_LIST -> NAMED_TEMPLATE_LIST:
 709         // value list -> assignment notation
 710         // applicable to record types, signatures and empty set types
 711         if (!my_governor) FATAL_ERROR("Template::set_templatetype()");
 712         Type *t = my_governor->get_type_refd_last();
 713         size_t nof_comps = t->get_nof_comps(); // "expected" nr of components
 714         Templates *sts = u.templates;
 715         size_t nof_temps = sts->get_nof_ts(); // "actual" nr in the list
 716         Type::typetype_t tt = t->get_typetype();
 717         switch (tt) {
 718         case Type::T_SEQ_T:
 719         case Type::T_SEQ_A:
 720         case Type::T_SIGNATURE:
 721           break;
 722         case Type::T_SET_A:
 723         case Type::T_SET_T:
 724           if (nof_temps == 0 && nof_comps == 0) break;
 725         default:
 726           FATAL_ERROR("Template::set_templatetype()");
 727         }
 728         // If it's a record or set template, allow fewer elements than
 729         // what is required, because implicit omit may take care of it.
 730         // If it's a signature template, be precise.
 731         bool allow_fewer = false;
 732         switch (my_governor->get_typetype()) {
 733         case Type::T_SEQ_T: case Type::T_SET_T:
 734           allow_fewer = true;
 735           break;
 736         case Type::T_SIGNATURE: // be precise
 737           break;
 738         default: // not possible, fatal error ?
 739           break;
 740         }
 741         if ( nof_temps > nof_comps
 742           || (!allow_fewer && (nof_temps < nof_comps))) {
 743           error("Too %s elements in value list notation for type `%s': "
 744             "%lu was expected instead of %lu",
 745             nof_temps > nof_comps ? "many" : "few",
 746               t->get_typename().c_str(),
 747               (unsigned long) nof_comps, (unsigned long) nof_temps);
 748         }
 749         size_t upper_limit; // min(nof_temps, nof_comps)
 750         bool all_notused;
 751         if (nof_temps <= nof_comps) {
 752           upper_limit = nof_temps;
 753           all_notused = true;
 754         } else {
 755           upper_limit = nof_comps;
 756           all_notused = false;
 757         }
 758         u.named_templates = new NamedTemplates;
 759         for (size_t i = 0; i < upper_limit; i++) {
 760           Template*& temp = sts->get_t_byIndex(i);
 761           if (temp->templatetype == TEMPLATE_NOTUSED) continue;
 762           all_notused = false;
 763           NamedTemplate *nt = new
 764             NamedTemplate(t->get_comp_id_byIndex(i).clone(), temp);
 765           nt->set_location(*temp);
 766           u.named_templates->add_nt(nt);
 767           temp = 0;
 768         }
 769         u.named_templates->set_my_scope(get_my_scope());
 770         u.named_templates->set_fullname(get_fullname());
 771         delete sts;
 772         if (all_notused && nof_temps > 0 && tt != Type::T_SIGNATURE)
 773           warning("All elements of value list notation for type `%s' are "
 774             "not used symbols (`-')", t->get_typename().c_str());
 775       } else FATAL_ERROR("Template::set_templatetype()");
 776       break;
 777     case CSTR_PATTERN: // current type
 778       if (p_templatetype == USTR_PATTERN)
 779         templatetype = USTR_PATTERN;
 780       else
 781         FATAL_ERROR("Template::set_templatetype()");
 782       break;
 783     default:
 784       FATAL_ERROR("Template::set_templatetype()");
 785     }
 786     templatetype = p_templatetype;
 787   }
 788
 789   const char *Template::get_templatetype_str() const
 790   {
 791     switch(templatetype) {
 792     case TEMPLATE_ERROR:
 793       return "erroneous template";
 794     case TEMPLATE_NOTUSED:
 795       return "not used symbol";
 796     case OMIT_VALUE:
 797       return "omit value";
 798     case ANY_VALUE:
 799       return "any value";
 800     case ANY_OR_OMIT:
 801       return "any or omit";
 802     case SPECIFIC_VALUE:
 803       return "specific value";
 804     case TEMPLATE_REFD:
 805       return "referenced template";
 806     case TEMPLATE_INVOKE:
 807       return "template returning invoke";
 808     case ALL_FROM:
 809     case VALUE_LIST_ALL_FROM:
 810       return "template with 'all from'";
 811     case TEMPLATE_LIST:
 812       return "value list notation";
 813     case NAMED_TEMPLATE_LIST:
 814       return "assignment notation";
 815     case INDEXED_TEMPLATE_LIST:
 816       return "assignment notation with array indices";
 817     case VALUE_RANGE:
 818       return "value range match";
 819     case VALUE_LIST:
 820       return "value list match";
 821     case COMPLEMENTED_LIST:
 822       return "complemented list match";
 823     case SUPERSET_MATCH:
 824       return "superset match";
 825     case SUBSET_MATCH:
 826       return "subset match";
 827     case PERMUTATION_MATCH:
 828       return "permutation match";
 829     case BSTR_PATTERN:
 830       return "bitstring pattern";
 831     case HSTR_PATTERN:
 832       return "hexstring pattern";
 833     case OSTR_PATTERN:
 834       return "octetstring pattern";
 835     case CSTR_PATTERN:
 836       return "character string pattern";
 837     case USTR_PATTERN:
 838       return "universal string pattern";
 839     default:
 840       return "unknown template";
 841     }
 842   }
 843
 844   bool Template::is_undef_lowerid()
 845   {
 846     return templatetype == SPECIFIC_VALUE &&
 847       u.specific_value->is_undef_lowerid();
 848   }
 849
 850   void Template::set_lowerid_to_ref()
 851   {
 852     switch (templatetype) {
 853     case SPECIFIC_VALUE:
 854       u.specific_value->set_lowerid_to_ref();
 855       if (u.specific_value->get_valuetype() == Value::V_REFD) {
 856         Common::Assignment *t_ass =
 857           u.specific_value->get_reference()->get_refd_assignment(false);
 858         if (t_ass) {
 859           switch (t_ass->get_asstype()) {
 860           case Common::Assignment::A_MODULEPAR_TEMP:
 861           case Common::Assignment::A_TEMPLATE:
 862           case Common::Assignment::A_VAR_TEMPLATE:
 863           case Common::Assignment::A_PAR_TEMPL_IN:
 864           case Common::Assignment::A_PAR_TEMPL_OUT:
 865           case Common::Assignment::A_PAR_TEMPL_INOUT:
 866           case Common::Assignment::A_FUNCTION_RTEMP:
 867           case Common::Assignment::A_EXT_FUNCTION_RTEMP:
 868             set_templatetype(TEMPLATE_REFD);
 869           default:
 870             break;
 871           }
 872         } else set_templatetype(TEMPLATE_ERROR);
 873       }
 874       break;
 875     case VALUE_LIST:
 876     case COMPLEMENTED_LIST:
 877       for (size_t i = 0; i < u.templates->get_nof_ts(); i++)
 878         u.templates->get_t_byIndex(i)->set_lowerid_to_ref();
 879       break;
 880     case VALUE_RANGE:
 881       u.value_range->set_lowerid_to_ref();
 882       break;
 883     default:
 884       break;
 885     }
 886   }
 887
 888   Type::typetype_t Template::get_expr_returntype(Type::expected_value_t exp_val)
 889   {
 890     switch (templatetype) {
 891     case TEMPLATE_ERROR:
 892       return Type::T_ERROR;
 893     case SPECIFIC_VALUE:
 894       return u.specific_value->get_expr_returntype(exp_val);
 895     case TEMPLATE_REFD: {
 896       Type *t = get_expr_governor(exp_val);
 897       if (t) return t->get_type_refd_last()->get_typetype_ttcn3();
 898       else return Type::T_ERROR; }
 899     case TEMPLATE_INVOKE: {
 900       Type *t = get_expr_governor(exp_val);
 901       if(t) return t->get_type_refd_last()->get_typetype_ttcn3();
 902       else return Type::T_ERROR; }
 903     case VALUE_LIST:
 904     case COMPLEMENTED_LIST:
 905       for (size_t i = 0; i < u.templates->get_nof_ts(); i++) {
 906         Type::typetype_t tt = u.templates->get_t_byIndex(i)
 907           ->get_expr_returntype(exp_val);
 908         if (tt != Type::T_UNDEF) return tt;
 909       }
 910       return Type::T_UNDEF;
 911     case VALUE_RANGE:
 912       return u.value_range->get_expr_returntype(exp_val);
 913     case SUPERSET_MATCH:
 914     case SUBSET_MATCH:
 915       return Type::T_SETOF;
 916     case BSTR_PATTERN:
 917       return Type::T_BSTR;
 918     case HSTR_PATTERN:
 919       return Type::T_HSTR;
 920     case OSTR_PATTERN:
 921       return Type::T_OSTR;
 922     case CSTR_PATTERN:
 923       return Type::T_CSTR;
 924     case USTR_PATTERN:
 925       return Type::T_USTR;
 926     default:
 927       return Type::T_UNDEF;
 928     }
 929   }
 930
 931   Type *Template::get_expr_governor(Type::expected_value_t exp_val)
 932   {
 933     if (my_governor) return my_governor;
 934     switch (templatetype) {
 935     case SPECIFIC_VALUE:
 936       return u.specific_value->get_expr_governor(exp_val);
 937     case VALUE_LIST:
 938     case COMPLEMENTED_LIST:
 939       for (size_t i = 0; i < u.templates->get_nof_ts(); i++) {
 940         Type *t = u.templates->get_t_byIndex(i)->get_expr_governor(exp_val);
 941         if (t) return t;
 942       }
 943       return 0;
 944     case VALUE_RANGE:
 945       return u.value_range->get_expr_governor(exp_val);
 946     case TEMPLATE_REFD: {
 947       Type *t = u.ref.ref->get_refd_assignment()->get_Type()
 948         ->get_field_type(u.ref.ref->get_subrefs(), exp_val);
 949       if (!t) set_templatetype(TEMPLATE_ERROR);
 950       return t;
 951       }
 952     case TEMPLATE_INVOKE: {
 953       Type *t = u.invoke.v->get_expr_governor(Type::EXPECTED_DYNAMIC_VALUE);
 954       if(!t) {
 955         if(u.invoke.v->get_valuetype() != Value::V_ERROR)
 956           u.invoke.v->error("A value of type function expected");
 957         goto error;
 958       }
 959       t = t->get_type_refd_last();
 960       switch(t->get_typetype()) {
 961       case Type::T_FUNCTION:
 962         if(exp_val==Type::EXPECTED_DYNAMIC_VALUE && t->get_returns_template()){
 963           error("Reference to a value was expected instead of a "
 964             "template of type `%s'"
 965             , t->get_function_return_type()->get_typename().c_str());
 966           goto error;
 967         }
 968         return t->get_function_return_type();
 969       case Type::T_ALTSTEP:
 970         goto error;
 971       default:
 972         u.invoke.v->error("A value of type function expected instead of `%s'",
 973           t->get_typename().c_str());
 974         goto error;
 975       }
 976       break; }
 977     default:
 978       return Type::get_pooltype(get_expr_returntype(exp_val));
 979     }
 980   error:
 981     set_templatetype(TEMPLATE_ERROR);
 982     return 0;
 983   }
 984
 985   void Template::set_my_governor(Type *p_gov)
 986   {
 987     if (!p_gov)
 988       FATAL_ERROR("Template::set_my_governor(): NULL parameter");
 989     my_governor=p_gov;
 990   }
 991
 992   Type *Template::get_my_governor() const
 993   {
 994     return my_governor;
 995   }
 996
 997   void Template::set_length_restriction(LengthRestriction *p_lr)
 998   {
 999     if (length_restriction) FATAL_ERROR("Template::set_length_restriction()");
1000     length_restriction = p_lr;
1001   }
1002
1003   Template::completeness_t
1004     Template::get_completeness_condition_seof(bool incomplete_allowed)
1005   {
1006     if (!incomplete_allowed) return C_MUST_COMPLETE;
1007     else if (!base_template) return C_MAY_INCOMPLETE;
1008     else {
1009       Template *t = base_template->get_template_refd_last();
1010       switch (t->templatetype) {
1011       // partial overwriting is allowed
1012       case TEMPLATE_ERROR: // to suppress more errors
1013       case TEMPLATE_NOTUSED:  // modifying a modified template
1014       case ANY_VALUE: // in case of ?
1015       case ANY_OR_OMIT: // in case of *
1016       case TEMPLATE_REFD: // e.g. the actual value of a formal parameter
1017       case TEMPLATE_INVOKE:
1018       case NAMED_TEMPLATE_LIST: // t is erroneous
1019       case INDEXED_TEMPLATE_LIST:
1020         return C_MAY_INCOMPLETE;
1021       case TEMPLATE_LIST:
1022         switch (my_governor->get_type_refd_last()->get_typetype()) {
1023         case Type::T_SEQOF:
1024         case Type::T_SETOF:
1025           // only the first elements can be incomplete
1026           return C_PARTIAL;
1027         default:
1028           // we are in error recovery
1029           return C_MAY_INCOMPLETE;
1030         }
1031         break; // should not get here
1032         default:
1033           // partial overwriting is not allowed for literal specific values,
1034           // matching ranges/lists/sets and patterns
1035           return C_MUST_COMPLETE;
1036       }
1037     }
1038   }
1039
1040   Template::completeness_t Template::get_completeness_condition_choice
1041     (bool incomplete_allowed, const Identifier& p_fieldname)
1042   {
1043     if (!incomplete_allowed) return C_MUST_COMPLETE;
1044     else if (!base_template) return C_MAY_INCOMPLETE;
1045     else {
1046       Template *t = base_template->get_template_refd_last();
1047       switch (t->templatetype) {
1048       // partial overwriting is allowed
1049       case TEMPLATE_ERROR: // to suppress more errors
1050       case TEMPLATE_NOTUSED:  // t is erroneous
1051       case ANY_VALUE: // in case of ?
1052       case ANY_OR_OMIT: // in case of *
1053       case TEMPLATE_REFD: // e.g. the actual value of a formal parameter
1054       case TEMPLATE_INVOKE:
1055       case TEMPLATE_LIST: // t is erroneous
1056         return C_MAY_INCOMPLETE;
1057       case NAMED_TEMPLATE_LIST: // some fields may be missing
1058         if (t->u.named_templates->has_nt_withName(p_fieldname))
1059           return C_MAY_INCOMPLETE;
1060         else return C_MUST_COMPLETE;
1061       default:
1062         // partial overwriting is not allowed for literal specific values,
1063         // matching ranges/lists/sets and patterns
1064         return C_MUST_COMPLETE;
1065       }
1066     }
1067   }
1068
1069   void Template::add_named_temp(NamedTemplate* nt) {
1070     if (templatetype != NAMED_TEMPLATE_LIST)
1071       FATAL_ERROR("Template::add_named_temp()");
1072     u.named_templates->add_nt(nt);
1073   }
1074
1075   Value *Template::get_specific_value() const
1076   {
1077     if (templatetype != SPECIFIC_VALUE)
1078       FATAL_ERROR("Template::get_specific_value()");
1079     return u.specific_value;
1080   }
1081
1082   Ref_base *Template::get_reference() const
1083   {
1084     if (templatetype != TEMPLATE_REFD)
1085       FATAL_ERROR("Template::get_reference()");
1086     return u.ref.ref;
1087   }
1088
1089   ValueRange *Template::get_value_range() const
1090   {
1091     if (templatetype != VALUE_RANGE)
1092       FATAL_ERROR("Template::get_value_range()");
1093     return u.value_range;
1094   }
1095
1096   PatternString* Template::get_cstr_pattern() const
1097   {
1098     if (templatetype != CSTR_PATTERN)
1099       FATAL_ERROR("Template::get_cstr_pattern()");
1100     return u.pstring;
1101   }
1102
1103   PatternString* Template::get_ustr_pattern() const
1104   {
1105     if (templatetype != USTR_PATTERN)
1106       FATAL_ERROR("Template::get_ustr_pattern()");
1107     return u.pstring;
1108   }
1109
1110   size_t Template::get_nof_comps() const
1111   {
1112     switch (templatetype) {
1113     case TEMPLATE_LIST:
1114     case VALUE_LIST:
1115     case COMPLEMENTED_LIST:
1116     case SUPERSET_MATCH:
1117     case SUBSET_MATCH:
1118     case PERMUTATION_MATCH:
1119       return u.templates->get_nof_ts();
1120     case NAMED_TEMPLATE_LIST:
1121       return u.named_templates->get_nof_nts();
1122     case INDEXED_TEMPLATE_LIST:
1123       return u.indexed_templates->get_nof_its();
1124     default:
1125       FATAL_ERROR("Template::get_of_comps()");
1126       return 0;
1127     }
1128   }
1129
1130   Template *Template::get_temp_byIndex(size_t n) const
1131   {
1132     switch (templatetype) {
1133     case TEMPLATE_LIST:
1134     case VALUE_LIST:
1135     case COMPLEMENTED_LIST:
1136     case SUPERSET_MATCH:
1137     case SUBSET_MATCH:
1138     case PERMUTATION_MATCH:
1139       return u.templates->get_t_byIndex(n);
1140     default:
1141       FATAL_ERROR("Template::get_temp_byIndex()");
1142       return 0;
1143     }
1144   }
1145
1146   IndexedTemplate *Template::get_indexedtemp_byIndex(size_t n) const
1147   {
1148     if (templatetype != INDEXED_TEMPLATE_LIST)
1149       FATAL_ERROR("Template::get_indexedtemp_byIndex()");
1150     return u.indexed_templates->get_it_byIndex(n);
1151   }
1152
1153   NamedTemplate *Template::get_namedtemp_byIndex(size_t n) const
1154   {
1155     if (templatetype != NAMED_TEMPLATE_LIST)
1156       FATAL_ERROR("Template::get_namedtemp_byIndex()");
1157     return u.named_templates->get_nt_byIndex(n);
1158   }
1159
1160   Template *Template::get_all_from() const
1161   {
1162     if (templatetype != ALL_FROM
1163       &&templatetype != VALUE_LIST_ALL_FROM)
1164       FATAL_ERROR("Template::get_all_from()");
1165     return u.all_from;
1166   }
1167
1168   // Not applicable to INDEXED_TEMPLATE_LIST nodes.  The actual number of
1169   // elements is not known.
1170   size_t Template::get_nof_listitems() const
1171   {
1172     if (templatetype != TEMPLATE_LIST)
1173       FATAL_ERROR("Template::get_nof_listitems()");
1174     if (has_permutation) {
1175       size_t nof_ts = u.templates->get_nof_ts(), ret_val = 0;
1176       for (size_t i = 0; i < nof_ts; i++) {
1177         Template *t = u.templates->get_t_byIndex(i);
1178         if (t->templatetype == PERMUTATION_MATCH)
1179           ret_val += t->u.templates->get_nof_ts();
1180         else ret_val++;
1181       }
1182       return ret_val;
1183     } else return u.templates->get_nof_ts();
1184   }
1185
1186   Template *Template::get_listitem_byIndex(size_t n) const
1187   {
1188     if (templatetype != TEMPLATE_LIST)
1189       FATAL_ERROR("Template::get_listitam_byIndex()");
1190     if (has_permutation) {
1191       size_t nof_ts = u.templates->get_nof_ts(), index = 0;
1192       for (size_t i = 0; i < nof_ts; i++) {
1193         Template *t = u.templates->get_t_byIndex(i);
1194         if (t->templatetype == PERMUTATION_MATCH) {
1195           size_t nof_perm_ts = t->u.templates->get_nof_ts();
1196           if (n < index + nof_perm_ts)
1197             return t->u.templates->get_t_byIndex(n - index);
1198           else index += nof_perm_ts;
1199         } else {
1200           if (n == index) return t;
1201           else index++;
1202         }
1203       }
1204       FATAL_ERROR("Template::get_listitem_byIndex(): index overflow");
1205       return 0;
1206     } else return u.templates->get_t_byIndex(n);
1207   }
1208
1209   /** \todo revise and merge with get_template_refd() */
1210   Template* Template::get_template_refd_last(ReferenceChain *refch)
1211   {
1212     // return this for non-referenced templates
1213     if (templatetype != TEMPLATE_REFD) return this;
1214     // use the cached template if present
1215     else if (u.ref.refd_last) return u.ref.refd_last;
1216     else {
1217       Common::Assignment *t_ass = u.ref.ref->get_refd_assignment();
1218       // escape from invalid recursion loops
1219       if (templatetype != TEMPLATE_REFD) return this;
1220       if (!t_ass) FATAL_ERROR("Template::get_template_refd_last()");
1221       if (t_ass->get_asstype() != Common::Assignment::A_TEMPLATE) {
1222         // return this if the reference does not point to a template
1223         u.ref.refd_last = this;
1224         return u.ref.refd_last;
1225       }
1226     }
1227     // otherwise evaluate the reference
1228     bool destroy_refch;
1229     if (refch) {
1230       refch->mark_state();
1231       destroy_refch = false;
1232     } else {
1233       refch = new ReferenceChain(this, "While searching referenced template");
1234       destroy_refch = true;
1235     }
1236     Template *ret_val;
1237     if (refch->add(get_fullname())) {
1238       Template *t_refd = get_template_refd(refch);
1239       // get_template_refd() may set u.ref.refd_last if there are unfoldable
1240       // sub-references in u.ref.ref
1241       if (!u.ref.refd_last) {
1242         u.ref.refd_last = t_refd->get_template_refd_last(refch);
1243       }
1244       ret_val = u.ref.refd_last;
1245     } else {
1246       // a circular reference was found
1247       set_templatetype(TEMPLATE_ERROR);
1248       ret_val = this;
1249     }
1250     if (destroy_refch) delete refch;
1251     else refch->prev_state();
1252     return ret_val;
1253   }
1254
1255   Template* Template::get_refd_sub_template(Ttcn::FieldOrArrayRefs *subrefs,
1256                                             bool usedInIsbound,
1257                                             ReferenceChain *refch)
1258   {
1259     if (!subrefs) return this;
1260     Template *t=this;
1261     for (size_t i=0; i<subrefs->get_nof_refs(); i++) {
1262       if(!t) break;
1263       t=t->get_template_refd_last(refch);
1264       t->set_lowerid_to_ref();
1265       switch(t->templatetype) {
1266       case TEMPLATE_ERROR:
1267         return t;
1268       case TEMPLATE_REFD:
1269       case INDEXED_TEMPLATE_LIST:
1270         // unfoldable stuff
1271         return this;
1272       case SPECIFIC_VALUE:
1273         (void)t->u.specific_value->get_refd_sub_value(
1274           subrefs, i, usedInIsbound, refch); // only to report errors
1275         break;
1276       default:
1277         break;
1278       } // switch
1279       Ttcn::FieldOrArrayRef *ref=subrefs->get_ref(i);
1280       if(ref->get_type() == Ttcn::FieldOrArrayRef::FIELD_REF)
1281         t=t->get_refd_field_template(*ref->get_id(), *ref, usedInIsbound,
1282             refch);
1283       else t=t->get_refd_array_template(ref->get_val(), usedInIsbound, refch);
1284     }
1285     return t;
1286   }
1287
1288   Template* Template::get_template_refd(ReferenceChain *refch)
1289   {
1290     unsigned int const prev_err_count = get_error_count();
1291     if (templatetype != TEMPLATE_REFD)
1292       FATAL_ERROR("Template::get_template_refd()");
1293     // use the cached pointer if it is already set
1294     if (u.ref.refd) return u.ref.refd;
1295     Common::Assignment *ass = u.ref.ref->get_refd_assignment();
1296     if (!ass) FATAL_ERROR("Template::get_template_refd()");
1297     if(ass->get_asstype() == Common::Assignment::A_TEMPLATE) {
1298       FieldOrArrayRefs *subrefs = u.ref.ref->get_subrefs();
1299       Template *asst = ass->get_Template();
1300       Template *t   = asst->get_refd_sub_template(
1301         subrefs, u.ref.ref->getUsedInIsbound(), refch);
1302       if (t) {
1303         u.ref.refd = t;
1304         // Why do we not set u.ref.refd_last ?
1305       }
1306       else if (subrefs && subrefs->has_unfoldable_index()) {
1307         // some array indices could not be evaluated
1308         u.ref.refd = this;
1309         u.ref.refd_last = this;
1310       } else if (u.ref.ref->getUsedInIsbound()) {
1311         u.ref.refd = this;
1312         u.ref.refd_last = this;
1313       } else {
1314         // an error was found while resolving sub-references
1315         if (get_error_count() == prev_err_count) {
1316           // it was not reported, report it now
1317           error("Using a template which refers to a non-template is not supported");
1318           asst->note("Workaround: change the right hand side refer to a template");
1319           if (ass->is_local()) {
1320             ass->note("Workaround: change the template definition "
1321               "to a var template");
1322           }
1323         }
1324         set_templatetype(TEMPLATE_ERROR);
1325         return this;
1326       }
1327     } else {
1328       // the reference is unfoldable
1329       u.ref.refd = this;
1330     }
1331     return u.ref.refd;
1332   }
1333
1334   Template* Template::get_refd_field_template(const Identifier& field_id,
1335     const Location& loc, bool usedInIsbound, ReferenceChain *refch)
1336   {
1337     switch (templatetype) {
1338     case OMIT_VALUE:
1339     case ANY_VALUE:
1340     case ANY_OR_OMIT:
1341     case VALUE_LIST:
1342     case COMPLEMENTED_LIST:
1343       // the above template types are valid matching mechanisms,
1344       // but they cannot be sub-referenced
1345       loc.error("Reference to field `%s' of %s `%s'",
1346         field_id.get_dispname().c_str(), get_templatetype_str(),
1347         get_fullname().c_str());
1348       break;
1349     default:
1350       break;
1351     }
1352     if(!my_governor) FATAL_ERROR("Template::get_refd_field_template()");
1353     Type *t = my_governor->get_type_refd_last();
1354     const char *typetype_str="set";
1355     switch(t->get_typetype()) {
1356     case Type::T_ERROR:
1357       // remain silent
1358       return 0;
1359     case Type::T_CHOICE_A:
1360     case Type::T_CHOICE_T:
1361     case Type::T_OPENTYPE:
1362     case Type::T_ANYTYPE:
1363       if (!t->has_comp_withName(field_id)) {
1364         loc.error("Reference to non-existent union field `%s' in type `%s'",
1365           field_id.get_dispname().c_str(), t->get_typename().c_str());
1366         return 0;
1367       } else if (templatetype != NAMED_TEMPLATE_LIST) {
1368         // this is an invalid matching mechanism, the error is already reported
1369 //error("invalid matching mechanism (not template list) but %d", templatetype);
1370         return 0;
1371       } else if (u.named_templates->get_nof_nts() != 1) {
1372         // this is an invalid union template (more than one active field)
1373         // the error is already reported
1374 //error("invalid union template ");
1375         return 0;
1376       } else {
1377         NamedTemplate *nt = u.named_templates->get_nt_byIndex(0);
1378         if (nt->get_name() != field_id) {
1379           if (!usedInIsbound) {
1380             loc.error("Reference to inactive field `%s' in a template of"
1381                     " union type `%s'. The active field is `%s'.",
1382                     field_id.get_dispname().c_str(),
1383                     t->get_typename().c_str(),
1384                     nt->get_name().get_dispname().c_str());
1385           }
1386           return 0;
1387         } else {
1388           // everything is OK
1389           return nt->get_template();
1390         }
1391       }
1392     case Type::T_SEQ_A:
1393     case Type::T_SEQ_T:
1394       typetype_str="record";
1395       // no break
1396     case Type::T_SET_A:
1397     case Type::T_SET_T:
1398       if (!t->has_comp_withName(field_id)) {
1399         loc.error("Reference to non-existent %s field `%s' in type `%s'",
1400           typetype_str, field_id.get_dispname().c_str(),
1401           t->get_typename().c_str());
1402         return 0;
1403       } else if (templatetype != NAMED_TEMPLATE_LIST) {
1404         // this is an invalid matching mechanism
1405         // the error should be already reported
1406         return 0;
1407       } else if (u.named_templates->has_nt_withName(field_id)) {
1408         // the field is found, everything is OK
1409         return u.named_templates->get_nt_byName(field_id)->get_template();
1410       } else if (base_template) {
1411         // take the field from the base template (recursively)
1412         return base_template->get_template_refd_last(refch)
1413           ->get_refd_field_template(field_id, loc, usedInIsbound, refch);
1414       } else {
1415         if (!usedInIsbound) {
1416           // this should not happen unless there is an error
1417           // (e.g. missing field)
1418           loc.error("Reference to an unbound field `%s'",
1419             field_id.get_dispname().c_str());
1420         }
1421         return 0;
1422       }
1423     default:
1424       loc.error("Invalid field reference `%s': type `%s' "
1425         "does not have fields", field_id.get_dispname().c_str(),
1426         t->get_typename().c_str());
1427       return 0;
1428     }
1429   }
1430
1431   Template* Template::get_refd_array_template(Value *array_index,
1432                                               bool usedInIsbound,
1433                                               ReferenceChain *refch)
1434   {
1435     switch (templatetype) {
1436     case OMIT_VALUE:
1437     case ANY_VALUE:
1438     case ANY_OR_OMIT:
1439     case VALUE_LIST:
1440     case COMPLEMENTED_LIST:
1441     case SUPERSET_MATCH:
1442     case SUBSET_MATCH:
1443       // the above template types are valid matching mechanisms,
1444       // but they cannot be sub-referenced
1445       array_index->error("Reference with index to an element of %s `%s'",
1446         get_templatetype_str(), get_fullname().c_str());
1447       break;
1448     default:
1449       break;
1450     }
1451     Value *v_index = array_index->get_value_refd_last(refch);
1452     Int index = 0;
1453     bool index_available = false;
1454     if (!v_index->is_unfoldable()) {
1455       if (v_index->get_valuetype() == Value::V_INT) {
1456         index = v_index->get_val_Int()->get_val();
1457         index_available = true;
1458       } else {
1459         array_index->error("An integer value was expected as index");
1460       }
1461     }
1462     if (!my_governor) FATAL_ERROR("Template::get_refd_array_template()");
1463     Type *t = my_governor->get_type_refd_last();
1464     const char *typetype_str="set";
1465     switch(t->get_typetype()) {
1466     case Type::T_ERROR:
1467       // remain silent
1468       return 0;
1469     case Type::T_SEQOF:
1470       typetype_str="record";
1471       // no break
1472     case Type::T_SETOF:
1473       if (index_available) {
1474         if(index < 0) {
1475           array_index->error("A non-negative integer value was expected "
1476             "instead of %s for indexing a template of `%s of' type `%s'",
1477             Int2string(index).c_str(), typetype_str,
1478             t->get_typename().c_str());
1479           return 0;
1480         } else if (templatetype != TEMPLATE_LIST) {
1481           // remain silent the error has been already reported
1482           return 0;
1483         } else {
1484           size_t nof_elements = get_nof_listitems();
1485           if (index >= static_cast<Int>(nof_elements)) {
1486             array_index->error("Index overflow in a template of `%s of' type "
1487               "`%s': the index is %s, but the template has only %lu elements",
1488               typetype_str, t->get_typename().c_str(),
1489               Int2string(index).c_str(), (unsigned long) nof_elements);
1490             return 0;
1491           }
1492         }
1493       } else {
1494         // the index is not available or the error has been reported above
1495         return 0;
1496       }
1497       break;
1498     case Type::T_ARRAY:
1499       if (index_available) {
1500         ArrayDimension *dim = t->get_dimension();
1501         dim->chk_index(v_index, Type::EXPECTED_DYNAMIC_VALUE);
1502         if (templatetype == TEMPLATE_LIST && !dim->get_has_error()) {
1503           // perform the index transformation
1504           index -= dim->get_offset();
1505           // check for index underflow/overflow or too few elements in template
1506           if (index < 0 || index >= static_cast<Int>(get_nof_listitems()))
1507             return 0;
1508         } else {
1509           // remain silent, the error has been already reported
1510           return 0;
1511         }
1512       } else {
1513         // the index is not available or the error has been reported above
1514         return 0;
1515       }
1516       break;
1517     default:
1518       array_index->error("Invalid array element reference: type `%s' cannot "
1519                          "be indexed", t->get_typename().c_str());
1520       return 0;
1521     }
1522     Template *ret_val = get_listitem_byIndex(index);
1523     if (ret_val->templatetype == TEMPLATE_NOTUSED) {
1524       if (base_template) {
1525         // take the referred element from the base template
1526         return base_template->get_template_refd_last(refch)
1527           ->get_refd_array_template(v_index, usedInIsbound, refch);
1528       } else {
1529         if(ret_val->get_templatetype() == TEMPLATE_NOTUSED)
1530                 error("Not used symbol is not allowed in this context");
1531         return 0;
1532       }
1533     } else return ret_val;
1534   }
1535
1536   bool Template::temps_contains_anyornone_symbol() const
1537   {
1538     switch (templatetype) {
1539     case TEMPLATE_LIST:
1540     case SUPERSET_MATCH:
1541     case SUBSET_MATCH:
1542     case PERMUTATION_MATCH:
1543       break;
1544     default:
1545       FATAL_ERROR("Template::temps_contains_anyornone_symbol()");
1546     }
1547     size_t nof_comps = u.templates->get_nof_ts();
1548     for (size_t i = 0; i < nof_comps; i++) {
1549       Template *t = u.templates->get_t_byIndex(i);
1550       switch (t->templatetype) {
1551       case ANY_OR_OMIT:
1552       case ALL_FROM:
1553         // 'all from' clauses not known at compile time are also considered
1554         // as 'AnyOrNone'
1555         return true;
1556       case PERMUTATION_MATCH:
1557         // walk recursively
1558         if (t->temps_contains_anyornone_symbol()) return true;
1559         break;
1560       default:
1561         break;
1562       }
1563     }
1564     return false;
1565   }
1566
1567   size_t Template::get_nof_comps_not_anyornone() const
1568   {
1569     switch (templatetype) {
1570     case TEMPLATE_LIST:
1571     case SUPERSET_MATCH:
1572     case SUBSET_MATCH:
1573     case PERMUTATION_MATCH:
1574       break;
1575     default:
1576       FATAL_ERROR("Template::get_nof_comps_not_anyornone()");
1577     }
1578     size_t ret_val = 0;
1579     size_t nof_comps = u.templates->get_nof_ts();
1580     for (size_t i = 0; i < nof_comps; i++) {
1581       Template *t = u.templates->get_t_byIndex(i);
1582       switch (t->templatetype) {
1583       case ANY_OR_OMIT:
1584       case ALL_FROM:
1585         // do not count it
1586         break;
1587       case PERMUTATION_MATCH:
1588         // walk recursively
1589         ret_val += t->get_nof_comps_not_anyornone();
1590         break;
1591      default:
1592         // other types are counted as 1
1593         ret_val++;
1594         break;
1595       }
1596     }
1597     return ret_val;
1598   }
1599
1600   bool Template::pattern_contains_anyornone_symbol() const
1601   {
1602     switch (templatetype) {
1603     case BSTR_PATTERN:
1604     case HSTR_PATTERN:
1605     case OSTR_PATTERN:
1606       return u.pattern->find('*') < u.pattern->size();
1607     case CSTR_PATTERN:
1608     case USTR_PATTERN:
1609       return true;
1610     default:
1611       FATAL_ERROR("Template::pattern_contains_anyornone_symbol()");
1612       return false;
1613     }
1614   }
1615
1616   size_t Template::get_min_length_of_pattern() const
1617   {
1618     size_t ret_val = 0;
1619     switch (templatetype) {
1620     case BSTR_PATTERN:
1621     case HSTR_PATTERN: {
1622       size_t pattern_len = u.pattern->size();
1623       const char *pattern_ptr = u.pattern->c_str();
1624       for (size_t i = 0; i < pattern_len; i++)
1625         if (pattern_ptr[i] != '*') ret_val++;
1626       break; }
1627     case OSTR_PATTERN: {
1628       size_t pattern_len = u.pattern->size();
1629       const char *pattern_ptr = u.pattern->c_str();
1630       for (size_t i = 0; i < pattern_len; i++) {
1631         switch (pattern_ptr[i]) {
1632         case '*':
1633           // do not count
1634           break;
1635         case '?':
1636           // count as 1
1637           ret_val++;
1638           break;
1639         default:
1640           // count as 1 and skip over the next hex digit
1641           ret_val++;
1642           i++;
1643         }
1644       }
1645       break; }
1646     case CSTR_PATTERN:
1647     case USTR_PATTERN:
1648       break;
1649     default:
1650       FATAL_ERROR("Template::get_min_length_of_pattern()");
1651     }
1652     return ret_val;
1653   }
1654
1655   bool Template::is_Value() const
1656   {
1657     if (length_restriction || is_ifpresent) return false;
1658     switch (templatetype) {
1659     case TEMPLATE_ERROR:
1660     case TEMPLATE_NOTUSED:
1661     case OMIT_VALUE:
1662       return true;
1663     case SPECIFIC_VALUE:
1664       if(u.specific_value->get_valuetype() == Value::V_INVOKE) {
1665         Type *t = u.specific_value
1666           ->get_invoked_type(Type::EXPECTED_DYNAMIC_VALUE);
1667         if(t && t->get_type_refd_last()->get_typetype() == Type::T_FUNCTION &&
1668           t->get_type_refd_last()->get_returns_template()) return false;
1669       }
1670       return true;
1671     case TEMPLATE_LIST: {
1672       Templates *ts = u.templates;
1673       for (size_t i = 0; i < ts->get_nof_ts(); i++)
1674         if (!ts->get_t_byIndex(i)->is_Value()) return false;
1675       return true;
1676     }
1677     case NAMED_TEMPLATE_LIST: {
1678       NamedTemplates *ts = u.named_templates;
1679       for (size_t i = 0;i < ts->get_nof_nts(); i++)
1680         if (!ts->get_nt_byIndex(i)->get_template()->is_Value()) return false;
1681       return true;
1682     }
1683     case INDEXED_TEMPLATE_LIST: {
1684       IndexedTemplates *ts = u.indexed_templates;
1685       for (size_t i = 0; i < ts->get_nof_its(); i++)
1686         if (!ts->get_it_byIndex(i)->get_template()->is_Value()) return false;
1687       return true;
1688     }
1689     case TEMPLATE_REFD: {
1690       Common::Assignment *ass = u.ref.ref->get_refd_assignment();
1691       switch (ass->get_asstype()) {
1692       case Common::Assignment::A_EXT_CONST:
1693       case Common::Assignment::A_PAR_VAL:
1694       case Common::Assignment::A_PAR_VAL_IN:
1695       case Common::Assignment::A_PAR_VAL_OUT:
1696       case Common::Assignment::A_PAR_VAL_INOUT:
1697       case Common::Assignment::A_VAR:
1698         return true;
1699       default:
1700         return false;
1701       }
1702     }
1703     default:
1704       return false;
1705     }
1706   }
1707
1708   Value *Template::get_Value()
1709   {
1710     Value *ret_val;
1711     switch(templatetype) {
1712     case TEMPLATE_ERROR:
1713       ret_val = new Value(Value::V_ERROR);
1714       break;
1715     case TEMPLATE_NOTUSED:
1716       ret_val = new Value(Value::V_NOTUSED);
1717       break;
1718     case OMIT_VALUE:
1719       ret_val = new Value(Value::V_OMIT);
1720       break;
1721     case SPECIFIC_VALUE:
1722       ret_val = u.specific_value;
1723       u.specific_value = 0;
1724       set_templatetype(TEMPLATE_ERROR);
1725       return ret_val;
1726     case TEMPLATE_LIST: {
1727       Values *vs = new Values;
1728       size_t nof_ts = u.templates->get_nof_ts();
1729       Type* gov = 0;
1730       for (size_t i = 0; i < nof_ts; i++) {
1731         Value* v = u.templates->get_t_byIndex(i)->get_Value();
1732         if (!gov) gov = v->get_my_governor();
1733         vs->add_v(v);
1734       }
1735       ret_val = new Value(Value::V_SEQOF, vs);
1736       if (gov) gov = gov->get_parent_type();
1737       if (gov) ret_val->set_my_governor(gov);
1738       break; }
1739     case NAMED_TEMPLATE_LIST: {
1740       NamedValues *nvs = new NamedValues;
1741       size_t nof_nts = u.named_templates->get_nof_nts();
1742       Type* gov = 0;
1743       for (size_t i = 0; i < nof_nts; i++) {
1744         NamedTemplate *nt = u.named_templates->get_nt_byIndex(i);
1745         Value* v = nt->get_template()->get_Value();
1746         if (!gov) gov = v->get_my_governor();
1747         NamedValue *nv = new NamedValue(nt->get_name().clone(), v);
1748         nv->set_location(*nt);
1749         nvs->add_nv(nv);
1750       }
1751       ret_val = new Value(Value::V_SEQ, nvs);
1752       if (gov) gov = gov->get_parent_type();
1753       if (gov) ret_val->set_my_governor(gov);
1754       break; }
1755     case INDEXED_TEMPLATE_LIST: {
1756       Values *ivs = new Values(true);
1757       size_t nof_its = u.indexed_templates->get_nof_its();
1758       Type* gov = 0;
1759       for (size_t i = 0; i < nof_its; i++) {
1760         IndexedTemplate *it = u.indexed_templates->get_it_byIndex(i);
1761         Value* v = it->get_template()->get_Value();
1762         if (!gov) gov = v->get_my_governor();
1763         IndexedValue *iv = new IndexedValue(it->get_index().clone(), v);
1764         iv->set_location(*it);
1765         ivs->add_iv(iv);
1766       }
1767       ret_val = new Value(Value::V_SEQOF, ivs);
1768       if (gov) gov = gov->get_parent_type();
1769       if (gov) ret_val->set_my_governor(gov);
1770       break; }
1771     default:
1772       FATAL_ERROR("Template::get_Value()");
1773       ret_val = 0;
1774       break;
1775     }
1776     ret_val->set_location(*this);
1777     ret_val->set_my_scope(get_my_scope());
1778     ret_val->set_fullname(get_fullname());
1779     return ret_val;
1780   }
1781
1782   bool Template::is_Ref() const
1783   {
1784     if (length_restriction || is_ifpresent || templatetype != SPECIFIC_VALUE)
1785       return false;
1786     Value *v = u.specific_value;
1787     switch (v->get_valuetype()) {
1788     case Value::V_UNDEF_LOWERID:
1789       return true;
1790     case Value::V_REFD:
1791       if (dynamic_cast<Ref_base*>(v->get_reference())) return true;
1792       else return false;
1793     default:
1794       return false;
1795     }
1796   }
1797
1798   Ref_base *Template::get_Ref()
1799   {
1800     if (templatetype != SPECIFIC_VALUE)
1801       FATAL_ERROR("Template::get_Ref()");
1802     return u.specific_value->steal_ttcn_ref_base();
1803   }
1804
1805   void Template::chk_recursions(ReferenceChain& refch)
1806   {
1807     if (recurs_checked) return;
1808     Template *t = this;
1809     for ( ; ; ) {
1810       if (t->templatetype == SPECIFIC_VALUE) break;
1811       else if (!refch.add(t->get_fullname())) goto end;
1812       else if (t->templatetype != TEMPLATE_REFD) break;
1813       ActualParList *parlist = t->u.ref.ref->get_parlist();
1814       if (parlist) parlist->chk_recursions(refch);
1815       Template *t_refd = t->get_template_refd(&refch);
1816       if (t_refd == t) break;
1817       else t = t_refd;
1818     }
1819     t->set_lowerid_to_ref();
1820     switch (t->templatetype) {
1821     case SPECIFIC_VALUE:
1822           t->u.specific_value->chk_recursions(refch);
1823       break;
1824     case TEMPLATE_LIST:
1825     case VALUE_LIST:
1826     case COMPLEMENTED_LIST:
1827     case SUPERSET_MATCH:
1828     case SUBSET_MATCH:
1829     case PERMUTATION_MATCH:
1830       for (size_t i = 0; i < t->u.templates->get_nof_ts(); i++) {
1831         refch.mark_state();
1832         t->u.templates->get_t_byIndex(i)->chk_recursions(refch);
1833         refch.prev_state();
1834       }
1835       break;
1836     case NAMED_TEMPLATE_LIST:
1837       for (size_t i = 0; i < t->u.named_templates->get_nof_nts(); i++) {
1838         refch.mark_state();
1839         t->u.named_templates->get_nt_byIndex(i)
1840           ->get_template()->chk_recursions(refch);
1841         refch.prev_state();
1842       }
1843       break;
1844     case INDEXED_TEMPLATE_LIST:
1845       for (size_t i = 0; i < t->u.indexed_templates->get_nof_its(); i++) {
1846         refch.mark_state();
1847         t->u.indexed_templates->get_it_byIndex(i)
1848           ->get_template()->chk_recursions(refch);
1849         refch.prev_state();
1850       }
1851       break;
1852     case CSTR_PATTERN:
1853     case USTR_PATTERN:
1854       t->u.pstring->chk_recursions(refch);
1855       break;
1856     default:
1857       break;
1858     }
1859 end:
1860     recurs_checked = true;
1861   }
1862
1863   void Template::chk_specific_value(bool allow_omit)
1864   {
1865     Template *t = get_template_refd_last();
1866     if (!allow_omit && t->templatetype==OMIT_VALUE) {
1867       t->error("A specific value was expected instead of omit");
1868     }
1869     chk_specific_value_generic();
1870   }
1871
1872   void Template::chk_specific_value_generic()
1873   {
1874     if (specific_value_checked) return;
1875     Template *t = get_template_refd_last();
1876     if (t->specific_value_checked) return;
1877     switch (t->templatetype) {
1878     case TEMPLATE_ERROR:
1879     case TEMPLATE_NOTUSED:
1880     case TEMPLATE_REFD: // unfoldable reference
1881       break;
1882     case SPECIFIC_VALUE:
1883       if(u.specific_value->get_valuetype() == Value::V_INVOKE) {
1884         Type *t_type = u.specific_value
1885           ->get_invoked_type(Type::EXPECTED_DYNAMIC_VALUE);
1886         if(t_type && t_type->get_type_refd_last()->get_returns_template()) {
1887           set_templatetype(TEMPLATE_INVOKE);
1888           chk_invoke();
1889         }
1890       }
1891       break;
1892     case TEMPLATE_INVOKE:
1893       chk_invoke();
1894       break;
1895     case TEMPLATE_LIST:
1896       for (size_t i = 0; i < t->u.templates->get_nof_ts(); i++)
1897         t->u.templates->get_t_byIndex(i)->chk_specific_value_generic();
1898       break;
1899     case NAMED_TEMPLATE_LIST:
1900       for (size_t i = 0; i < t->u.named_templates->get_nof_nts(); i++)
1901         t->u.named_templates->get_nt_byIndex(i)
1902           ->get_template()->chk_specific_value_generic();
1903       break;
1904     case INDEXED_TEMPLATE_LIST:
1905       for (size_t i = 0; i < t->u.indexed_templates->get_nof_its(); i++)
1906         t->u.indexed_templates->get_it_byIndex(i)
1907           ->get_template()->chk_specific_value_generic();
1908       break;
1909     case OMIT_VALUE:
1910       break;
1911     default:
1912       t->error("A specific value was expected instead of %s",
1913         t->get_templatetype_str());
1914       break;
1915     }
1916     t->specific_value_checked = true;
1917     specific_value_checked = true;
1918   }
1919
1920   void Template::chk_invoke()
1921   {
1922     if(templatetype != TEMPLATE_INVOKE) FATAL_ERROR("Template::chk_invoke()");
1923     if(!u.invoke.t_list) return; //already checked
1924     Error_Context cntxt(this, "In `apply()' operation");
1925     Type *t = u.invoke.v->get_expr_governor_last();
1926     if (t) {
1927       if (t->get_typetype() != Type::T_FUNCTION) {
1928         u.invoke.v->error("A value of type function was expected in the "
1929           "argument instead of `%s'", t->get_typename().c_str());
1930         set_templatetype(TEMPLATE_ERROR);
1931         return;
1932       }
1933     } else {
1934       if (u.invoke.v->get_valuetype() != Value::V_ERROR)
1935         u.invoke.v->error("A value of type function was expected in the "
1936           "argument");
1937       set_templatetype(TEMPLATE_ERROR);
1938       return;
1939     }
1940     my_scope->chk_runs_on_clause(t, *this, "call");
1941     Ttcn::FormalParList *fp_list = t->get_fat_parameters();
1942     Ttcn::ActualParList *parlist = new Ttcn::ActualParList;
1943     bool is_erroneous = fp_list->fold_named_and_chk(u.invoke.t_list,parlist);
1944     delete u.invoke.t_list;
1945     u.invoke.t_list = 0;
1946     if(is_erroneous) {
1947       delete parlist;
1948       u.invoke.ap_list = 0;
1949     } else {
1950       parlist->set_fullname(get_fullname());
1951       parlist->set_my_scope(get_my_scope());
1952       u.invoke.ap_list = parlist;
1953     }
1954   }
1955
1956   Templates *Template::harbinger(Template *t, bool from_permutation, bool killer)
1957   {
1958     Templates *new_templates = new Templates;
1959     switch (t->u.all_from->templatetype) {
1960     case SPECIFIC_VALUE: {
1961       Value *innerv = t->u.all_from->get_specific_value();
1962       //if (v->get_valuetype() == Value::V_UNDEF_LOWERID)
1963       innerv->set_lowerid_to_ref();
1964       // should be a ref now
1965       bool can_flatten = true;
1966       Common::Reference  *ref = innerv->get_reference();
1967       if (dynamic_cast<Ttcn::Ref_pard*>(ref)) {
1968         // Cannot flatten at compile time if the template has parameters.
1969         can_flatten = false;
1970       }
1971
1972       // check for subreferences in the 'all from' target
1973       FieldOrArrayRefs* subrefs = ref->get_subrefs();
1974       if (NULL != subrefs) {
1975         for (size_t i = 0; i < subrefs->get_nof_refs(); ++i) {
1976           FieldOrArrayRef* subref = subrefs->get_ref(i);
1977           if (FieldOrArrayRef::ARRAY_REF == subref->get_type()) {
1978             // set any array indexes from undefined lowerID to reference
1979             subref->get_val()->set_lowerid_to_ref();
1980           }
1981         }
1982       }
1983
1984       Common::Assignment *ass = ref->get_refd_assignment();
1985       if (ass == NULL) { // perhaps erroneous
1986         break;
1987       }
1988
1989       Common::Assignment::asstype_t asst = ass->get_asstype();
1990       switch (asst) {
1991       case Common::Assignment::A_TEMPLATE: {
1992         Template *tpl = ass->get_Template();
1993         // tpl is the template whose name appears after the "all from"
1994         Common::Type *type = ass->get_Type()->get_type_refd_last();
1995         if (NULL != subrefs) {
1996           // walk through the subreferences to determine the type and value of the 'all from' target
1997           // Note: the templates referenced by the array indexes and field names
1998           // have not been checked yet
1999           for (size_t i = 0; i < subrefs->get_nof_refs(); ++i) {
2000             FieldOrArrayRef* subref = subrefs->get_ref(i);
2001             if (FieldOrArrayRef::ARRAY_REF == subref->get_type()) {
2002               // check if the type can be indexed
2003               Common::Type::typetype_t tt = type->get_typetype();
2004               if (Common::Type::T_SEQOF != tt && Common::Type::T_SETOF != tt &&
2005                   Common::Type::T_ARRAY != tt) {
2006                 subref->error("Cannot apply an array index to type '%s'",
2007                   type->get_typename().c_str());
2008                 i = subrefs->get_nof_refs(); // quit from the cycle, too
2009                 tpl = NULL;
2010                 break;
2011               }
2012               if (can_flatten && !subref->get_val()->is_unfoldable()) {
2013                 switch(tpl->get_templatetype()) {
2014                 case TEMPLATE_LIST:
2015                 case VALUE_LIST: {
2016                   Int index = subref->get_val()->get_val_Int()->get_val();
2017                   // check for index overflow
2018                   if (index >= static_cast<Int>(tpl->get_nof_comps())) {
2019                     subref->error("Index overflow in a template %s type `%s':"
2020                       " the index is %s, but the template has only %lu elements",
2021                       Common::Type::T_ARRAY == tt ? "array of" :
2022                       (Common::Type::T_SEQOF == tt ? "of 'record of'" : "of 'set of'"),
2023                       type->get_typename().c_str(), Int2string(index).c_str(),
2024                       (unsigned long)tpl->get_nof_comps());
2025                     i = subrefs->get_nof_refs(); // quit from the cycle, too
2026                     tpl = NULL;
2027                     break;
2028                   }
2029                   tpl = tpl->get_temp_byIndex(index);
2030                   // check if the element is initialized
2031                   if (TEMPLATE_NOTUSED == tpl->get_templatetype()) {
2032                     subref->error("An uninitialized list element can not be used as target of 'all from'");
2033                     i = subrefs->get_nof_refs(); // quit from the cycle, too
2034                     tpl = NULL;
2035                     break;
2036                   }
2037                   break; }
2038                 case INDEXED_TEMPLATE_LIST:
2039                   can_flatten = false; // currently not supported
2040                   break;
2041                 default:
2042                   subref->error("Expected a specific value of type '%s' instead of %s",
2043                     type->get_typename().c_str(), tpl->get_templatetype_str());
2044                   i = subrefs->get_nof_refs(); // quit from the cycle, too
2045                   tpl = NULL;
2046                   break;
2047                 }
2048               }
2049               else {
2050                 // one of the array indexes is a reference => cannot flatten
2051                 can_flatten = false;
2052               }
2053               type = type->get_ofType()->get_type_refd_last();
2054             }
2055             else { // FIELD_REF
2056               // check if the type can have fields
2057               Common::Type::typetype_t tt = type->get_typetype();
2058               if (Common::Type::T_SEQ_T != tt && Common::Type::T_SEQ_A != tt &&
2059                   Common::Type::T_SET_T != tt && Common::Type::T_SET_A != tt &&
2060                   Common::Type::T_CHOICE_T != tt && Common::Type::T_CHOICE_A != tt) {
2061                 subref->error("Cannot apply a field name to type '%s'",
2062                   type->get_typename().c_str());
2063                 tpl = NULL;
2064                 break;
2065               }
2066               // check if the field name is valid
2067               if (!type->has_comp_withName(*subref->get_id())) {
2068                 subref->error("Type '%s' does not have a field with name '%s'",
2069                   type->get_typename().c_str(), subref->get_id()->get_dispname().c_str());
2070                 tpl = NULL;
2071                 break;
2072               }
2073               if (can_flatten) {
2074                 switch(tpl->get_templatetype()) {
2075                 case NAMED_TEMPLATE_LIST: {
2076                   // check if there is any data in the template for this field
2077                   // (no data means it's uninitialized)
2078                   if (!tpl->u.named_templates->has_nt_withName(*subref->get_id())) {
2079                     subref->error("An uninitialized field can not be used as target of 'all from'");
2080                     i = subrefs->get_nof_refs(); // quit from the cycle, too
2081                     tpl = NULL;
2082                     break;
2083                   }
2084                   tpl = tpl->u.named_templates->get_nt_byName(*subref->get_id())->get_template();
2085                   // check if the field is initialized and present (not omitted)
2086                   if (OMIT_VALUE == tpl->get_templatetype() || TEMPLATE_NOTUSED == tpl->get_templatetype()) {
2087                     subref->error("An %s field can not be used as target of 'all from'",
2088                       OMIT_VALUE == tpl->get_templatetype() ? "omitted" : "uninitialized");
2089                     i = subrefs->get_nof_refs(); // quit from the cycle, too
2090                     tpl = NULL;
2091                     break;
2092                   }
2093                   break; }
2094                 default:
2095                   subref->error("Expected a specific value of type '%s' instead of %s",
2096                     type->get_typename().c_str(), tpl->get_templatetype_str());
2097                   i = subrefs->get_nof_refs(); // quit from the cycle, too
2098                   tpl = NULL;
2099                   break;
2100                 }
2101               }
2102               type = type->get_comp_byName(*subref->get_id())->get_type()->get_type_refd_last();
2103             }
2104           }
2105         }
2106         if (NULL != tpl) { // tpl is set to null if an error occurs
2107           if (can_flatten) {
2108             Template::templatetype_t tpltt = tpl->get_templatetype();
2109             switch (tpltt) {
2110             case INDEXED_TEMPLATE_LIST: // currently not supported
2111             case TEMPLATE_REFD: {
2112               delete new_templates;
2113               new_templates = 0;
2114               killer = false;
2115             break; }
2116
2117             case TEMPLATE_LIST:
2118           // ALL_FROM ?
2119             case VALUE_LIST: {
2120               size_t nvl = tpl->get_nof_comps();
2121               for (size_t ti = 0; ti < nvl; ++ti) {
2122               Template *orig = tpl->get_temp_byIndex(ti);
2123                 switch (orig->templatetype) {
2124                 case SPECIFIC_VALUE: {
2125                   Value *val = orig->get_specific_value();
2126                   if (val->get_valuetype() == Value::V_REFD) {
2127                     if (dynamic_cast<Ttcn::Ref_pard*>(val->get_reference())) {
2128                       // Cannot flatten at compile time if one of the values or templates has parameters.
2129                       can_flatten = false;
2130                     }
2131                   }
2132                   break; }
2133                 case ANY_OR_OMIT:
2134                   if (from_permutation) {
2135                     break; // AnyElementOrNone allowed in "all from" now
2136                   }
2137                   // no break
2138                 case PERMUTATION_MATCH:
2139                   t->error("'all from' can not refer to permutation or AnyElementsOrNone");
2140                   t->set_templatetype(TEMPLATE_ERROR);
2141                 default:
2142                   break;
2143                 }
2144               }
2145               if (can_flatten) {
2146                 for (size_t ti = 0; ti < nvl; ++ti) {
2147                 Template *orig = tpl->get_temp_byIndex(ti);
2148                   Template *copy = orig->clone();
2149                   copy->set_my_scope(orig->get_my_scope());
2150                   new_templates->add_t(copy);
2151                 }
2152               }
2153               else {
2154                 // Cannot flatten at compile time
2155                 delete new_templates;
2156                 new_templates = 0;
2157                 killer = false;
2158               }
2159               break; }
2160
2161             case NAMED_TEMPLATE_LIST: {
2162               size_t nvl = tpl->get_nof_comps();
2163               for (size_t ti = 0; ti < nvl; ++ti) {
2164                 NamedTemplate *orig = tpl->get_namedtemp_byIndex(ti);
2165                 switch (orig->get_template()->get_templatetype()) {
2166                   case ANY_OR_OMIT:
2167                     break;
2168                   case PERMUTATION_MATCH:
2169                     t->error("'all from' can not refer to permutation or AnyElementsOrNone");
2170                     t->set_templatetype(TEMPLATE_ERROR);
2171                   default:
2172                     break;
2173                 }
2174               }
2175               delete new_templates;
2176               new_templates = 0;
2177               killer = false;
2178               break; }
2179
2180             case ANY_VALUE:
2181             case ANY_OR_OMIT:
2182               tpl->error("Matching mechanism can not be used as target of 'all from'");
2183               break;
2184             default:
2185               tpl->error("A template of type '%s' can not be used as target of 'all from'",
2186                 type->get_typename().c_str());
2187               break;
2188             }
2189           }
2190           else { // cannot flatten
2191             switch (type->get_typetype()) {
2192             case Common::Type::T_SEQOF: case Common::Type::T_SETOF:
2193             case Common::Type::T_ARRAY:
2194               delete new_templates;
2195               new_templates = 0;
2196               killer = false;
2197               break;
2198             default:
2199               type->error("A template of type `%s' can not be used as target of 'all from'",
2200                 type->get_typename().c_str());
2201               break;
2202             } // switch(typetype)
2203           }
2204         }
2205
2206         if (killer) delete t;
2207         break; }
2208
2209
2210       case Common::Assignment::A_CONST: { // all from a constant definition
2211         Common::Value *val = ass->get_Value();
2212         Common::Type *type = ass->get_Type()->get_type_refd_last();
2213         if (NULL != subrefs) {
2214           // walk through the subreferences to determine the type and value of the 'all from' target
2215           for (size_t i = 0; i < subrefs->get_nof_refs(); ++i) {
2216             FieldOrArrayRef* subref = subrefs->get_ref(i);
2217             if (FieldOrArrayRef::ARRAY_REF == subref->get_type()) {
2218               // check if the type can be indexed
2219               Common::Type::typetype_t tt = type->get_typetype();
2220               if (Common::Type::T_SEQOF != tt && Common::Type::T_SETOF != tt &&
2221                   Common::Type::T_ARRAY != tt) {
2222                 subref->error("Cannot apply an array index to type '%s'",
2223                   type->get_typename().c_str());
2224                 val = NULL;
2225                 break;
2226               }
2227               if (can_flatten && !subref->get_val()->is_unfoldable()) {
2228                 Int index = subref->get_val()->get_val_Int()->get_val();
2229                 // check for index overflow
2230                 if (index >= static_cast<Int>(val->get_nof_comps())) {
2231                   subref->error("Index overflow in a value %s type `%s':"
2232                     " the index is %s, but the template has only %lu elements",
2233                     Common::Type::T_ARRAY == tt ? "array of" :
2234                     (Common::Type::T_SEQOF == tt ? "of 'record of'" : "of 'set of'"),
2235                     type->get_typename().c_str(), Int2string(index).c_str(),
2236                     (unsigned long)val->get_nof_comps());
2237                   val = NULL;
2238                   break;
2239                 }
2240                 val = val->get_comp_byIndex(index);
2241                 // check if the element is initialized
2242                 if (Common::Value::V_NOTUSED == val->get_valuetype()) {
2243                   subref->error("An unbound list element can not be used as target of 'all from'");
2244                   val = NULL;
2245                   break;
2246                 }
2247               }
2248               else {
2249                 // one of the array indexes is a reference => cannot flatten
2250                 can_flatten = false;
2251               }
2252               type = type->get_ofType()->get_type_refd_last();
2253             }
2254             else { // FIELD_REF
2255               // check if the type can have fields
2256               Common::Type::typetype_t tt = type->get_typetype();
2257               if (Common::Type::T_SEQ_T != tt && Common::Type::T_SEQ_A != tt &&
2258                   Common::Type::T_SET_T != tt && Common::Type::T_SET_A != tt &&
2259                   Common::Type::T_CHOICE_T != tt && Common::Type::T_CHOICE_A != tt) {
2260                 subref->error("Cannot apply a field name to type '%s'",
2261                   type->get_typename().c_str());
2262                 val = NULL;
2263                 break;
2264               }
2265               // check if the field name is valid
2266               if (!type->has_comp_withName(*subref->get_id())) {
2267                 subref->error("Type '%s' does not have a field with name '%s'",
2268                   type->get_typename().c_str(), subref->get_id()->get_dispname().c_str());
2269                 val = NULL;
2270                 break;
2271               }
2272               type = type->get_comp_byName(*subref->get_id())->get_type()->get_type_refd_last();
2273               if (can_flatten) {
2274                 // check if the value has any data for this field (no data = unbound)
2275                 if (!val->has_comp_withName(*subref->get_id())) {
2276                   subref->error("An unbound field can not be used as target of 'all from'");
2277                   val = NULL;
2278                   break;
2279                 }
2280                 val = val->get_comp_value_byName(*subref->get_id());
2281                 // check if the field is bound and present (not omitted)
2282                 if (Common::Value::V_OMIT == val->get_valuetype() ||
2283                     Common::Value::V_NOTUSED == val->get_valuetype()) {
2284                   subref->error("An %s field can not be used as target of 'all from'",
2285                     Common::Value::V_OMIT == val->get_valuetype() ? "omitted" : "unbound");
2286                   val = NULL;
2287                   break;
2288                 }
2289               }
2290             }
2291           }
2292         }
2293         if (NULL != val) { // val is set to null if an error occurs
2294           switch (type->get_typetype()) {
2295           case Common::Type::T_SEQOF: case Common::Type::T_SETOF:
2296           case Common::Type::T_ARRAY: {
2297             if (can_flatten) {
2298               const size_t ncomp = val->get_nof_comps();
2299               for (size_t i = 0; i < ncomp; ++i) {
2300                 Value *v = val->get_comp_byIndex(i);
2301                 Template *newt = new Template(v->clone());
2302                 new_templates->add_t(newt);
2303               }
2304             }
2305             else {
2306               delete new_templates;
2307               new_templates = 0;
2308               killer = false;
2309             }
2310             break; }
2311
2312           default:
2313             type->error("A constant of type `%s' can not be used as target of 'all from'",
2314               type->get_typename().c_str());
2315             break;
2316           } // switch(typetype)
2317         }
2318         if (killer) delete t;
2319         break; }
2320
2321       case Common::Assignment::A_MODULEPAR_TEMP:
2322       case Common::Assignment::A_VAR_TEMPLATE:
2323       case Common::Assignment::A_FUNCTION_RTEMP:
2324       case Common::Assignment::A_EXT_FUNCTION_RTEMP:
2325       case Common::Assignment::A_PAR_TEMPL_IN:
2326       case Common::Assignment::A_PAR_TEMPL_INOUT:
2327       case Common::Assignment::A_PAR_TEMPL_OUT:
2328 //TODO: flatten if the actual par is const template
2329       case Common::Assignment::A_MODULEPAR: // all from a module parameter
2330       case Common::Assignment::A_VAR: // all from a variable
2331       case Common::Assignment::A_PAR_VAL_IN:
2332       case Common::Assignment::A_PAR_VAL_INOUT:
2333       case Common::Assignment::A_PAR_VAL_OUT:
2334       case Common::Assignment::A_FUNCTION_RVAL:
2335       case Common::Assignment::A_EXT_FUNCTION_RVAL: {
2336         Common::Type *type = ass->get_Type()->get_type_refd_last();
2337         if (NULL != subrefs) {
2338           // walk through the subreferences to determine the type of the 'all from' target
2339           for (size_t i = 0; i < subrefs->get_nof_refs(); ++i) {
2340             FieldOrArrayRef* subref = subrefs->get_ref(i);
2341             if (FieldOrArrayRef::ARRAY_REF == subref->get_type()) {
2342               // check if the type can be indexed
2343               Common::Type::typetype_t tt = type->get_typetype();
2344               if (Common::Type::T_SEQOF != tt && Common::Type::T_SETOF != tt &&
2345                   Common::Type::T_ARRAY != tt) {
2346                 subref->error("Cannot apply an array index to type '%s'",
2347                   type->get_typename().c_str());
2348                 type = NULL;
2349                 break;
2350               }
2351               type = type->get_ofType()->get_type_refd_last();
2352             }
2353             else { // FIELD_REF
2354               // check if the type can have fields
2355               Common::Type::typetype_t tt = type->get_typetype();
2356               if (Common::Type::T_SEQ_T != tt && Common::Type::T_SEQ_A != tt &&
2357                   Common::Type::T_SET_T != tt && Common::Type::T_SET_A != tt &&
2358                   Common::Type::T_CHOICE_T != tt && Common::Type::T_CHOICE_A != tt) {
2359                 subref->error("Cannot apply a field name to type '%s'",
2360                   type->get_typename().c_str());
2361                 type = NULL;
2362                 break;
2363               }
2364               // check if the field name is valid
2365               if (!type->has_comp_withName(*subref->get_id())) {
2366                 subref->error("Type '%s' does not have a field with name '%s'",
2367                   type->get_typename().c_str(), subref->get_id()->get_dispname().c_str());
2368                 type = NULL;
2369                 break;
2370               }
2371               type = type->get_comp_byName(*subref->get_id())->get_type()->get_type_refd_last();
2372             }
2373           }
2374         }
2375         if (NULL != type) {
2376           switch (type->get_typetype()) {
2377           case Common::Type::T_SEQOF: case Common::Type::T_SETOF:
2378           case Common::Type::T_ARRAY:
2379             delete new_templates; // cannot flatten at compile time
2380             new_templates = 0;
2381             break;
2382           default: {
2383             // not an array type => error
2384             const char* ass_name = ass->get_assname();
2385             string descr;
2386             switch(asst) {
2387             case Common::Assignment::A_MODULEPAR_TEMP:
2388             case Common::Assignment::A_VAR_TEMPLATE:
2389             case Common::Assignment::A_MODULEPAR:
2390             case Common::Assignment::A_VAR:
2391             case Common::Assignment::A_PAR_TEMPL_IN:
2392             case Common::Assignment::A_PAR_VAL_IN:
2393               descr = "A ";
2394               descr += ass_name;
2395               break;
2396             case Common::Assignment::A_PAR_TEMPL_INOUT:
2397             case Common::Assignment::A_PAR_TEMPL_OUT:
2398             case Common::Assignment::A_PAR_VAL_INOUT:
2399             case Common::Assignment::A_PAR_VAL_OUT:
2400               descr = "An ";
2401               descr += ass_name;
2402               break;
2403             // the assignment name string for functions is no good here
2404             case Common::Assignment::A_FUNCTION_RTEMP:
2405               descr = "A function returning a template";
2406               break;
2407             case Common::Assignment::A_FUNCTION_RVAL:
2408               descr = "A function returning a value";
2409               break;
2410             case Common::Assignment::A_EXT_FUNCTION_RTEMP:
2411               descr = "An external function returning a template";
2412               break;
2413             case Common::Assignment::A_EXT_FUNCTION_RVAL:
2414               descr = "An external function returning a value";
2415               break;
2416             default:
2417               break;
2418             }
2419             type->error("%s of type `%s' can not be used as target of 'all from'",
2420               descr.c_str(), type->get_typename().c_str());
2421             break; }
2422           }
2423         } // switch(typetype)
2424         break; }
2425
2426       default:
2427         FATAL_ERROR("harbinger asst %d", asst);
2428         break;
2429       }
2430       break; }
2431
2432     case ALL_FROM:
2433       FATAL_ERROR("unexpected all from inside all from");
2434       break;
2435     default:
2436       FATAL_ERROR("tt %d", t->u.all_from->templatetype);
2437     }
2438
2439     return new_templates;
2440   }
2441
2442   bool Template::flatten(bool from_permutation)
2443   {
2444     switch (templatetype) {
2445     case TEMPLATE_LIST:
2446     case VALUE_LIST:
2447     case COMPLEMENTED_LIST:
2448     case SUPERSET_MATCH:
2449     case SUBSET_MATCH:
2450     case PERMUTATION_MATCH: {
2451       size_t num_t = u.templates->get_nof_ts(); // one of these is the "all from"
2452       Templates *new_templates = new Templates;
2453       for (size_t i = 0; i < num_t; ++i) {
2454         Template *& t = u.templates->get_t_byIndex(i);
2455         // the element in the (,,,)
2456         switch (t->templatetype) {
2457         case VALUE_LIST_ALL_FROM: {
2458           // the all from from something like subset(1, (all from...), 99)
2459           // value list: one out of many possible values^^^^^^^^^^^^^
2460           Location tloc(*t); // save the location info
2461           string tname(t->get_fullname());
2462           Templates *ha = harbinger(t, from_permutation, true);
2463           if (ha) {
2464             // Don't touch t from now on, it might have been deleted!
2465             Template *qq = new Template(VALUE_LIST, ha);
2466             qq->set_location(tloc);
2467             qq->set_fullname(tname + ".all_from");
2468             new_templates->add_t(qq);
2469           }
2470           else {
2471             new_templates->add_t(t); // transfer it unchanged
2472             flattened = false;
2473           }
2474           break; }
2475
2476         case ALL_FROM: { // subset(1, all from ..., 99)
2477           // some number of elements--^^^^^^^^^^^^
2478           if (t->checked) FATAL_ERROR("too late");
2479           Templates *af = harbinger(t, from_permutation, true);
2480           if (af) {
2481             for (size_t a = 0, num = af->get_nof_ts(); a < num; ++a) {
2482               Template *& t2 = af->get_t_byIndex(a);
2483               new_templates->add_t(t2);
2484               t2 = 0; // take it away from its current owner
2485             }
2486             delete af;
2487           }
2488           else {
2489             new_templates->add_t(t); // transfer it unchanged
2490             flattened = false;
2491           }
2492           break; } // case ALL_FROM
2493
2494         case PERMUTATION_MATCH: {
2495           // permut inside a value list: { 1, permut(), 2 }
2496           flattened &= t->flatten(true);
2497           new_templates->add_t(t);
2498           break; }
2499         case TEMPLATE_LIST:
2500        // case VALUE_LIST:
2501        // case COMPLEMENTED_LIST:
2502        // case SUPERSET_MATCH:
2503        // case SUBSET_MATCH:
2504        {
2505           flattened &=t->flatten(false);
2506           new_templates->add_t(t);
2507           break; }
2508         default:
2509           new_templates->add_t(t);
2510         }
2511
2512         t = 0; // take it away from the original
2513       }
2514       delete u.templates;
2515       u.templates = new_templates;
2516 //printf("!!! flattened from %lu to %lu at line %d\n",
2517 //  (unsigned long)num_t, (unsigned long)new_templates->get_nof_ts(),
2518 //  get_first_line());
2519
2520       break; }
2521
2522     case VALUE_LIST_ALL_FROM: {
2523       Templates *new_templates = harbinger(this, from_permutation, false);
2524       if (new_templates) {
2525         delete u.all_from;
2526         // now we can change the type
2527         templatetype = VALUE_LIST;
2528         u.templates = new_templates;
2529       }
2530       break; }
2531
2532     case TEMPLATE_ERROR: case TEMPLATE_NOTUSED:
2533     case OMIT_VALUE:     case ANY_VALUE: case ANY_OR_OMIT:
2534     case SPECIFIC_VALUE:
2535     case TEMPLATE_REFD:  case TEMPLATE_INVOKE:
2536     case NAMED_TEMPLATE_LIST: case INDEXED_TEMPLATE_LIST:
2537     case VALUE_RANGE:
2538     case ALL_FROM:
2539     case BSTR_PATTERN: case HSTR_PATTERN: case OSTR_PATTERN:
2540     case CSTR_PATTERN: case USTR_PATTERN:
2541       break; // NOP
2542     }
2543
2544     set_fullname(get_fullname()); // recompute fullname (esp. for components)
2545     set_my_scope(get_my_scope());
2546
2547     return flattened;
2548   }
2549
2550   const char* Template::get_restriction_name(template_restriction_t tr)
2551   {
2552     switch (tr) {
2553     case TR_NONE:
2554       break;
2555     case TR_OMIT:
2556       return "omit";
2557     case TR_VALUE:
2558       return "value";
2559     case TR_PRESENT:
2560       return "present";
2561     default:
2562       FATAL_ERROR("Template::get_restriction_name()");
2563     }
2564     return "";
2565   }
2566
2567   template_restriction_t Template::get_sub_restriction(
2568     template_restriction_t tr, Ref_base* ref)
2569   {
2570     if (!ref) FATAL_ERROR("Template::get_sub_restriction()");
2571     if (!ref->get_subrefs()) return tr;
2572     bool is_optional = true; // the referenced field is on an optional path
2573     Common::Assignment* ass = ref->get_refd_assignment();
2574     if (ass) {
2575       Type* t = ass->get_Type();
2576       if (t) {
2577         ReferenceChain refch(ref, "While checking template restriction");
2578         t = t->get_field_type(ref->get_subrefs(), Type::EXPECTED_TEMPLATE,
2579                               &refch, true);
2580         if (t) is_optional = false;
2581       }
2582     }
2583     switch (tr) {
2584     case TR_NONE:
2585       return TR_NONE;
2586     case TR_OMIT:
2587       return TR_OMIT;
2588     case TR_VALUE:
2589       return is_optional ? TR_OMIT : TR_VALUE;
2590     case TR_PRESENT:
2591       return is_optional ? TR_NONE : TR_PRESENT;
2592     default:
2593       FATAL_ERROR("Template::get_sub_restriction()");
2594     }
2595     return tr;
2596   }
2597
2598   bool Template::is_less_restrictive(template_restriction_t needed_tr,
2599     template_restriction_t refd_tr)
2600   {
2601     switch (needed_tr) {
2602     case TR_NONE:
2603       return false;
2604     case TR_VALUE:
2605       return refd_tr!=TR_VALUE;
2606     case TR_OMIT:
2607       return refd_tr!=TR_VALUE && refd_tr!=TR_OMIT;
2608     case TR_PRESENT:
2609       return refd_tr!=TR_VALUE && refd_tr!=TR_PRESENT;
2610     default:
2611       FATAL_ERROR("Template::is_less_restrictive()");
2612     }
2613     return true;
2614   }
2615
2616   char* Template::generate_restriction_check_code(char* str, const char* name,
2617     template_restriction_t tr)
2618   {
2619     const char* tr_name;
2620     switch (tr) {
2621     case TR_NONE:
2622       return str;
2623     case TR_OMIT:
2624       tr_name = "TR_OMIT";
2625       break;
2626     case TR_VALUE:
2627       tr_name = "TR_VALUE";
2628       break;
2629     case TR_PRESENT:
2630       tr_name = "TR_PRESENT";
2631       break;
2632     default:
2633       FATAL_ERROR("Template::generate_restriction_check_code()");
2634     }
2635     return mputprintf(str, "%s.check_restriction(%s%s);\n", name, tr_name,
2636       (omit_in_value_list ? ", NULL, TRUE" : ""));
2637   }
2638
2639   // embedded templates -> check needed only for case of TR_OMIT
2640   bool Template::chk_restriction_named_list(const char* definition_name,
2641     map<string, void>& checked_map, size_t needed_checked_cnt,
2642     const Location* usage_loc)
2643   {
2644     bool needs_runtime_check = false;
2645     if (checked_map.size()>=needed_checked_cnt) return needs_runtime_check;
2646     switch (templatetype) {
2647     case NAMED_TEMPLATE_LIST:
2648       for (size_t i = 0;i < u.named_templates->get_nof_nts(); i++) {
2649         Template* tmpl = u.named_templates->get_nt_byIndex(i)->get_template();
2650         const string& name =
2651           u.named_templates->get_nt_byIndex(i)->get_name().get_name();
2652         if (!checked_map.has_key(name)) {
2653           bool nrc = tmpl->chk_restriction(definition_name, TR_OMIT, usage_loc);
2654           needs_runtime_check = needs_runtime_check || nrc;
2655           checked_map.add(name, 0);
2656         }
2657       }
2658       if (base_template) {
2659         bool nrc = base_template->chk_restriction_named_list(definition_name,
2660                      checked_map, needed_checked_cnt, usage_loc);
2661         needs_runtime_check = needs_runtime_check || nrc;
2662       }
2663       break;
2664     case ANY_VALUE:
2665     case ANY_OR_OMIT:
2666       error("Restriction on %s does not allow usage of %s",
2667             definition_name, get_templatetype_str());
2668       break;
2669     default:
2670       // others will be converted to specific value
2671       break;
2672     }
2673     return needs_runtime_check;
2674   }
2675
2676   bool Template::chk_restriction_refd(const char* definition_name,
2677     template_restriction_t template_restriction, const Location* usage_loc)
2678   {
2679     bool needs_runtime_check = false;
2680     Common::Assignment* ass = u.ref.ref->get_refd_assignment();
2681     if (!ass) FATAL_ERROR("Template::chk_restriction_refd()");
2682     // get the restriction on the referenced template
2683     template_restriction_t refd_tr = TR_NONE;
2684     bool is_var_template = false;
2685     switch (ass->get_asstype()) {
2686     case Common::Assignment::A_TEMPLATE: {
2687       Template* t_last = get_template_refd_last();
2688       if (t_last!=this) {
2689         bool nrc = t_last->chk_restriction(definition_name,
2690           template_restriction, usage_loc);
2691         needs_runtime_check = needs_runtime_check || nrc;
2692       }
2693       break; }
2694     case Common::Assignment::A_MODULEPAR_TEMP:
2695       is_var_template = true;
2696       refd_tr = TR_NONE; // can't place restriction on this thing
2697       break;
2698     case Common::Assignment::A_VAR_TEMPLATE: {
2699       Def_Var_Template* dvt = dynamic_cast<Def_Var_Template*>(ass);
2700       if (!dvt) FATAL_ERROR("Template::chk_restriction_refd()");
2701       is_var_template = true;
2702       refd_tr = dvt->get_template_restriction();
2703       break; }
2704     case Common::Assignment::A_EXT_FUNCTION_RTEMP:
2705       // we do not trust external functions because there is no generated
2706       // restriction check on their return value
2707       if (template_restriction!=TR_NONE) needs_runtime_check = true;
2708       // no break
2709     case Common::Assignment::A_FUNCTION_RTEMP: {
2710       Def_Function_Base* dfb = dynamic_cast<Def_Function_Base*>(ass);
2711       if (!dfb) FATAL_ERROR("Template::chk_restriction_refd()");
2712       is_var_template = true;
2713       refd_tr = dfb->get_template_restriction();
2714       break; }
2715     case Common::Assignment::A_PAR_TEMPL_IN:
2716     case Common::Assignment::A_PAR_TEMPL_OUT:
2717     case Common::Assignment::A_PAR_TEMPL_INOUT: {
2718       FormalPar* fp = dynamic_cast<FormalPar*>(ass);
2719       if (!fp) FATAL_ERROR("Template::chk_restriction_refd()");
2720       is_var_template = true;
2721       refd_tr = fp->get_template_restriction();
2722       break; }
2723     default:
2724       break;
2725     }
2726     if (is_var_template) {
2727       // check the restriction
2728       refd_tr = get_sub_restriction(refd_tr, u.ref.ref);
2729       // if restriction not satisfied issue warning
2730       if (is_less_restrictive(template_restriction, refd_tr)) {
2731         needs_runtime_check = true;
2732         warning("Inadequate restriction on the referenced %s `%s', this may "
2733           "cause a dynamic test case error at runtime", ass->get_assname(),
2734           u.ref.ref->get_dispname().c_str());
2735         ass->note("Referenced %s is here", ass->get_assname());
2736       }
2737     }
2738     return needs_runtime_check;
2739   }
2740
2741   bool Template::chk_restriction(const char* definition_name,
2742                                  template_restriction_t template_restriction,
2743                                  const Location* usage_loc)
2744   {
2745     bool needs_runtime_check = false;
2746     bool erroneous = false;
2747     switch (template_restriction) {
2748     case TR_NONE:
2749       break;
2750     case TR_OMIT:
2751     case TR_VALUE:
2752       if (length_restriction) {
2753         usage_loc->error("Restriction on %s does not allow usage of length "
2754           "restriction", definition_name);
2755         erroneous = true;
2756       }
2757       if (is_ifpresent) {
2758         usage_loc->error("Restriction on %s does not allow usage of `ifpresent'",
2759           definition_name);
2760         erroneous = true;
2761       }
2762       switch(templatetype) {
2763       case TEMPLATE_ERROR:
2764         break;
2765       case TEMPLATE_NOTUSED:
2766         if (base_template) {
2767           bool nrc = base_template->chk_restriction(definition_name,
2768             template_restriction, usage_loc);
2769           needs_runtime_check = needs_runtime_check || nrc;
2770         }
2771         else needs_runtime_check = true;
2772         break;
2773       case SPECIFIC_VALUE:
2774       case TEMPLATE_INVOKE:
2775         break;
2776       case TEMPLATE_REFD: {
2777         bool nrc = chk_restriction_refd(definition_name, template_restriction,
2778           usage_loc);
2779         needs_runtime_check = needs_runtime_check || nrc;
2780       } break;
2781       case TEMPLATE_LIST:
2782         for (size_t i = 0; i < u.templates->get_nof_ts(); i++) {
2783           bool nrc = u.templates->get_t_byIndex(i)->
2784                        chk_restriction(definition_name, TR_OMIT, usage_loc);
2785           needs_runtime_check = needs_runtime_check || nrc;
2786         }
2787         break;
2788       case NAMED_TEMPLATE_LIST: {
2789         map<string, void> checked_map;
2790         size_t needed_checked_cnt = 0;
2791         if (base_template && my_governor) {
2792           switch (my_governor->get_typetype()) {
2793           case Type::T_SEQ_A:
2794           case Type::T_SEQ_T:
2795           case Type::T_SET_A:
2796           case Type::T_SET_T:
2797           case Type::T_SIGNATURE:
2798             needed_checked_cnt = my_governor->get_nof_comps();
2799             break;
2800           default:
2801             break;
2802           }
2803         }
2804         for (size_t i = 0;i < u.named_templates->get_nof_nts(); i++) {
2805           bool nrc = u.named_templates->get_nt_byIndex(i)->get_template()->
2806                        chk_restriction(definition_name, TR_OMIT, usage_loc);
2807           needs_runtime_check = needs_runtime_check || nrc;
2808           if (needed_checked_cnt)
2809             checked_map.add(
2810               u.named_templates->get_nt_byIndex(i)->get_name().get_name(), 0);
2811         }
2812         if (needed_checked_cnt) {
2813           bool nrc = base_template->chk_restriction_named_list(definition_name,
2814                        checked_map, needed_checked_cnt, usage_loc);
2815           needs_runtime_check = needs_runtime_check || nrc;
2816           checked_map.clear();
2817         }
2818       } break;
2819       case INDEXED_TEMPLATE_LIST:
2820         for (size_t i = 0; i < u.indexed_templates->get_nof_its(); i++) {
2821           bool nrc = u.indexed_templates->get_it_byIndex(i)->get_template()->
2822                        chk_restriction(definition_name, TR_OMIT, usage_loc);
2823           needs_runtime_check = needs_runtime_check || nrc;
2824         }
2825         needs_runtime_check = true; // only basic check, needs runtime check
2826         break;
2827       case OMIT_VALUE:
2828         if (template_restriction==TR_OMIT) break;
2829         // Else restriction is TR_VALUE, but template type is OMIT:
2830         // fall through to error.
2831       default:
2832         usage_loc->error("Restriction on %s does not allow usage of %s",
2833           definition_name, get_templatetype_str());
2834         erroneous = true;
2835         break;
2836       }
2837       break;
2838     case TR_PRESENT:
2839       if (is_ifpresent) {
2840         usage_loc->error("Restriction on %s does not allow usage of `ifpresent'",
2841           definition_name);
2842         erroneous = true;
2843       }
2844       switch(templatetype) {
2845       case TEMPLATE_REFD: {
2846         bool nrc = chk_restriction_refd(definition_name, template_restriction,
2847           usage_loc);
2848         needs_runtime_check = needs_runtime_check || nrc;
2849       } break;
2850       case VALUE_LIST:
2851         for (size_t i = 0; i < u.templates->get_nof_ts(); i++) {
2852           bool nrc = u.templates->get_t_byIndex(i)->
2853             chk_restriction(definition_name, template_restriction, usage_loc);
2854           needs_runtime_check = needs_runtime_check || nrc;
2855         }
2856         break;
2857       case COMPLEMENTED_LIST:
2858         // some basic check, always needs runtime check
2859         needs_runtime_check = true;
2860         if (omit_in_value_list) {
2861           bool has_any_or_omit = false;
2862           for (size_t i = 0; i < u.templates->get_nof_ts(); i++) {
2863             templatetype_t item_templatetype =
2864             u.templates->get_t_byIndex(i)->templatetype;
2865             if (item_templatetype==OMIT_VALUE || item_templatetype==ANY_OR_OMIT) {
2866               has_any_or_omit = true;
2867               break;
2868             }
2869           }
2870           if (!has_any_or_omit) {
2871             usage_loc->error("Restriction on %s does not allow usage of %s without "
2872               "omit or AnyValueOrNone in the list", definition_name,
2873               get_templatetype_str());
2874             erroneous = true;
2875           }
2876         }
2877         break;
2878       case OMIT_VALUE:
2879       case ANY_OR_OMIT:
2880         usage_loc->error("Restriction on %s does not allow usage of %s",
2881           definition_name, get_templatetype_str());
2882         erroneous = true;
2883         break;
2884       default:
2885         break; // all others are ok
2886       }
2887       break;
2888     default:
2889       FATAL_ERROR("Template::chk_restriction()");
2890     }
2891     if (erroneous && usage_loc != this) {
2892       // display the template's location, too
2893       note("Referenced template is here");
2894     }
2895     return needs_runtime_check;
2896   }
2897
2898   void Template::generate_code_expr(expression_struct *expr,
2899     template_restriction_t template_restriction)
2900   {
2901     // Only templates without extra matching attributes can be directly
2902     // represented in a C++ expression.
2903     if (!length_restriction && !is_ifpresent
2904         && template_restriction == TR_NONE) {
2905       // The single expression must be tried first because this rule might
2906       // cover some referenced templates.
2907       if (has_single_expr()) {
2908         expr->expr = mputstr(expr->expr, get_single_expr(true).c_str());
2909         return;
2910       }
2911       switch (templatetype) {
2912       case SPECIFIC_VALUE:
2913         // A simple specific value: use explicit cast.
2914         expr->expr = mputprintf(expr->expr, "%s(",
2915           my_governor->get_genname_template(my_scope).c_str());
2916         u.specific_value->generate_code_expr(expr);
2917         expr->expr = mputc(expr->expr, ')');
2918         return;
2919       case TEMPLATE_REFD:
2920         // A simple unfoldable referenced template.
2921         if (!get_needs_conversion()) {
2922           u.ref.ref->generate_code(expr);
2923         } else {
2924           Type *my_gov = get_expr_governor(Type::EXPECTED_TEMPLATE)
2925             ->get_type_refd_last();
2926           Type *refd_gov = u.ref.ref->get_refd_assignment()->get_Type()
2927             ->get_field_type(u.ref.ref->get_subrefs(),
2928             Type::EXPECTED_TEMPLATE)->get_type_refd_last();
2929           if (!my_gov || !refd_gov || my_gov == refd_gov)
2930             FATAL_ERROR("Template::generate_code_expr()");
2931           expression_struct expr_tmp;
2932           Code::init_expr(&expr_tmp);
2933           const string& tmp_id1 = get_temporary_id();
2934           const char *tmp_id_str1 = tmp_id1.c_str();
2935           const string& tmp_id2 = get_temporary_id();
2936           const char *tmp_id_str2 = tmp_id2.c_str();
2937           expr->preamble = mputprintf(expr->preamble,
2938             "%s %s;\n", refd_gov->get_genname_template(my_scope).c_str(),
2939             tmp_id_str1);
2940           expr_tmp.expr = mputprintf(expr_tmp.expr, "%s = ", tmp_id_str1);
2941           u.ref.ref->generate_code(&expr_tmp);
2942           expr->preamble = Code::merge_free_expr(expr->preamble, &expr_tmp);
2943           expr->preamble = mputprintf(expr->preamble,
2944             "%s %s;\n"
2945             "if (!%s(%s, %s)) TTCN_error(\"Values or templates of types `%s' "
2946             "and `%s' are not compatible at run-time\");\n",
2947             my_gov->get_genname_template(my_scope).c_str(), tmp_id_str2,
2948             TypeConv::get_conv_func(refd_gov, my_gov, get_my_scope()
2949             ->get_scope_mod()).c_str(), tmp_id_str2, tmp_id_str1, my_gov
2950             ->get_typename().c_str(), refd_gov->get_typename().c_str());
2951           expr->expr = mputprintf(expr->expr, "%s", tmp_id_str2);
2952         }
2953         return;
2954       case TEMPLATE_INVOKE:
2955         generate_code_expr_invoke(expr);
2956         return;
2957       default:
2958         break;
2959       }
2960     }
2961     // if none of the above methods are applicable use the most generic and
2962     // least efficient solution
2963     // create a temporary object, initialize it and use it in the expression
2964     const string& tmp_id = get_temporary_id();
2965     const char *tmp_id_str = tmp_id.c_str();
2966
2967     expr->preamble = mputprintf(expr->preamble, "%s %s;\n",
2968       my_governor->get_genname_template(my_scope).c_str(), tmp_id_str);
2969     set_genname_recursive(tmp_id);
2970     expr->preamble = generate_code_init(expr->preamble, tmp_id_str);
2971     if (template_restriction != TR_NONE)
2972       expr->preamble = Template::generate_restriction_check_code(expr->preamble,
2973                          tmp_id_str, template_restriction);
2974     expr->expr = mputstr(expr->expr, tmp_id_str);
2975   }
2976
2977   char *Template::generate_code_init(char *str, const char *name)
2978   {
2979     if (get_code_generated()) return str;
2980     set_code_generated();
2981     if (err_descr) {
2982       str = err_descr->generate_code_init_str(str, string(name)+"_err_descr");
2983     }
2984     switch (templatetype) {
2985     case OMIT_VALUE:
2986     case ANY_VALUE:
2987     case ANY_OR_OMIT:
2988     case BSTR_PATTERN:
2989     case HSTR_PATTERN:
2990     case OSTR_PATTERN:
2991     case CSTR_PATTERN:
2992     case USTR_PATTERN:
2993       str = mputprintf(str, "%s = %s;\n", name, get_single_expr(false).c_str());
2994       break;
2995     case SPECIFIC_VALUE:
2996       if (get_code_section() == CS_POST_INIT)
2997         str = u.specific_value->rearrange_init_code(str);
2998       str = u.specific_value->generate_code_init(str, name);
2999       break;
3000     case TEMPLATE_REFD:
3001       str = generate_code_init_refd(str, name);
3002       break;
3003     case TEMPLATE_INVOKE:
3004       if (get_code_section() == CS_POST_INIT)
3005         str = rearrange_init_code_invoke(str);
3006       str = generate_code_init_invoke(str, name);
3007       break;
3008     case TEMPLATE_LIST:
3009     case INDEXED_TEMPLATE_LIST:
3010       str = generate_code_init_seof(str, name);
3011       break;
3012     case NAMED_TEMPLATE_LIST:
3013       str = generate_code_init_se(str, name);
3014       break;
3015     case VALUE_LIST_ALL_FROM:
3016       str = generate_code_init_all_from_list(str, name);
3017       break;
3018     case ALL_FROM:
3019       str = generate_code_init_all_from(str, name);
3020       break;
3021     case VALUE_LIST:
3022       str = generate_code_init_list(str, name, false);
3023       break;
3024     case COMPLEMENTED_LIST:
3025       str = generate_code_init_list(str, name, true);
3026       break;
3027     case VALUE_RANGE:
3028       if (get_code_section() == CS_POST_INIT)
3029         str = u.value_range->rearrange_init_code(str);
3030       str = u.value_range->generate_code_init(str, name);
3031       break;
3032     case SUPERSET_MATCH:
3033       str = generate_code_init_set(str, name, true);
3034       break;
3035     case SUBSET_MATCH:
3036       str = generate_code_init_set(str, name, false);
3037       break;
3038     case PERMUTATION_MATCH:
3039       warning("Don't know how to init PERMUT");
3040       str = mputprintf(str, "/* FIXME: PERMUT goes here, name=%s*/\n", name);
3041       break;
3042     case TEMPLATE_ERROR:
3043     case TEMPLATE_NOTUSED:
3044       // "default"
3045       FATAL_ERROR("Template::generate_code_init()");
3046     }
3047     if (length_restriction) {
3048       if (get_code_section() == CS_POST_INIT)
3049         str = length_restriction->rearrange_init_code(str);
3050       str = length_restriction->generate_code_init(str, name);
3051     }
3052     if (is_ifpresent) str = mputprintf(str, "%s.set_ifpresent();\n", name);
3053     if (err_descr) {
3054       str = mputprintf(str, "%s.set_err_descr(&%s_err_descr);\n", name, name);
3055     }
3056     return str;
3057   }
3058
3059   char *Template::rearrange_init_code(char *str)
3060   {
3061     switch (templatetype) {
3062     case SPECIFIC_VALUE:
3063       str = u.specific_value->rearrange_init_code(str);
3064       break;
3065     case TEMPLATE_REFD:
3066       str = rearrange_init_code_refd(str);
3067       break;
3068     case TEMPLATE_INVOKE:
3069       str = rearrange_init_code_invoke(str);
3070       break;
3071     case TEMPLATE_LIST:
3072     case VALUE_LIST:
3073     case COMPLEMENTED_LIST:
3074     case SUPERSET_MATCH:
3075     case SUBSET_MATCH:
3076     case PERMUTATION_MATCH:
3077       for (size_t i = 0; i < u.templates->get_nof_ts(); i++)
3078         str = u.templates->get_t_byIndex(i)->rearrange_init_code(str);
3079       break;
3080     case NAMED_TEMPLATE_LIST:
3081       for (size_t i = 0; i < u.named_templates->get_nof_nts(); i++)
3082         str = u.named_templates->get_nt_byIndex(i)->get_template()
3083         ->rearrange_init_code(str);
3084       break;
3085     case INDEXED_TEMPLATE_LIST:
3086       for (size_t i = 0; i < u.indexed_templates->get_nof_its(); i++)
3087         str = u.indexed_templates->get_it_byIndex(i)->get_template()
3088           ->rearrange_init_code(str);
3089       break;
3090     case VALUE_RANGE:
3091       str = u.value_range->rearrange_init_code(str);
3092       break;
3093     default:
3094       break;
3095     }
3096     if (length_restriction) str = length_restriction->rearrange_init_code(str);
3097     return str;
3098   }
3099
3100   bool Template::use_single_expr_for_init()
3101   {
3102     Template *t_last = get_template_refd_last();
3103     // return false in case of unfoldable references
3104     if (t_last->templatetype == TEMPLATE_REFD) return false;
3105     // return false if t_last is in a different module
3106     if (t_last->my_scope->get_scope_mod_gen() != my_scope->get_scope_mod_gen())
3107       return false;
3108     // return false if t_last cannot be represented by a single expression
3109     if (!t_last->has_single_expr()) return false;
3110     // return true if t_last is a generic wildcard, string pattern, etc.
3111     if (t_last->templatetype != SPECIFIC_VALUE) return true;
3112     // examine the specific value
3113     Value *v_last = t_last->u.specific_value->get_value_refd_last();
3114     switch (v_last->get_valuetype()) {
3115     case Value::V_EXPR:
3116       // do not calculate expressions again
3117       return false;
3118     case Value::V_REFD: {
3119       // v_last is an unfoldable value reference
3120       // the scope of the definition that v_last refers to
3121       Scope *v_scope =
3122         v_last->get_reference()->get_refd_assignment()->get_my_scope();
3123       for (Scope *t_scope = my_scope; t_scope;
3124         t_scope = t_scope->get_parent_scope()) {
3125         // return true if the referred definition is in the same scope
3126         // as this or in one of the parent scopes of this
3127         if (t_scope == v_scope) return true;
3128       }
3129       // otherwise return false
3130       return false; }
3131     default:
3132       // return true only if v_last is defined in the same module as this
3133       return v_last->get_my_scope()->get_scope_mod_gen() ==
3134           my_scope->get_scope_mod_gen();
3135     }
3136   }
3137
3138   char *Template::generate_code_init_refd(char *str, const char *name)
3139   {
3140     if (use_single_expr_for_init() && has_single_expr()) {
3141       str = mputprintf(str, "%s = %s;\n", name,
3142                        get_single_expr(false).c_str());
3143     } else {
3144       expression_struct expr;
3145       Code::init_expr(&expr);
3146       bool use_ref_for_codegen = true;
3147       if (get_code_section() == CS_POST_INIT) {
3148         // the referencing template is a part of a non-parameterized template
3149         Common::Assignment *ass = u.ref.ref->get_refd_assignment();
3150         if (ass->get_asstype() == Common::Assignment::A_TEMPLATE &&
3151             ass->get_my_scope()->get_scope_mod_gen() ==
3152             my_scope->get_scope_mod_gen()) {
3153           // the reference points to (a field of) a template
3154           // within the local module
3155           if (ass->get_FormalParList()) {
3156             // the referred template is parameterized
3157             // generate the initialization sequence first for all dependent
3158             // non-parameterized templates
3159             str = rearrange_init_code_refd(str);
3160           } else {
3161             // the referred template is non-parameterized
3162             // use a different algorithm for code generation
3163             str = generate_rearrange_init_code_refd(str, &expr);
3164             use_ref_for_codegen = false;
3165           }
3166         }
3167       }
3168       if (use_ref_for_codegen) u.ref.ref->generate_code_const_ref(&expr);
3169       if (expr.preamble || expr.postamble) {
3170         // the expressions within reference need temporary objects
3171         str = mputstr(str, "{\n");
3172         str = mputstr(str, expr.preamble);
3173         if (use_runtime_2 && get_needs_conversion()) {
3174           const string& tmp_id = get_temporary_id();
3175           const char *tmp_id_str = tmp_id.c_str();
3176           Type *my_gov = my_governor->get_type_refd_last();
3177           Type *refd_gov = u.ref.ref->get_refd_assignment()->get_Type()
3178             ->get_type_refd_last();
3179           if (!my_gov || !refd_gov)
3180             FATAL_ERROR("Template::generate_code_init_refd()");
3181           str = mputprintf(str,
3182             "%s %s;\n"
3183             "if (!%s(%s, %s)) TTCN_error(\"Values or templates of types `%s' "
3184             "and `%s' are not compatible at run-time\");\n",
3185             my_gov->get_genname_template(my_scope).c_str(), tmp_id_str,
3186             TypeConv::get_conv_func(refd_gov, my_gov, get_my_scope()
3187             ->get_scope_mod()).c_str(), tmp_id_str, expr.expr, my_gov
3188             ->get_typename().c_str(), refd_gov->get_typename().c_str());
3189           str = mputprintf(str, "%s = %s;\n", name, tmp_id_str);
3190         } else {
3191           str = mputprintf(str, "%s = %s;\n", name, expr.expr);
3192         }
3193         str = mputstr(str, expr.postamble);
3194         str = mputstr(str, "}\n");
3195       } else {
3196         // the reference does not need temporary objects
3197         if (use_runtime_2 && get_needs_conversion()) {
3198           const string& tmp_id = get_temporary_id();
3199           const char *tmp_id_str = tmp_id.c_str();
3200           Type *my_gov = my_governor->get_type_refd_last();
3201           Type *refd_gov = u.ref.ref->get_refd_assignment()->get_Type()
3202             ->get_type_refd_last();
3203           if (!my_gov || !refd_gov)
3204             FATAL_ERROR("Template::generate_code_init_refd()");
3205           str = mputprintf(str,
3206             "%s %s;\n"
3207             "if (!%s(%s, %s)) TTCN_error(\"Values or templates of types `%s' "
3208             "and `%s' are not compatible at run-time\");\n",
3209             my_gov->get_genname_template(my_scope).c_str(), tmp_id_str,
3210             TypeConv::get_conv_func(refd_gov, my_gov, get_my_scope()
3211             ->get_scope_mod()).c_str(), tmp_id_str, expr.expr, my_gov
3212             ->get_typename().c_str(), refd_gov->get_typename().c_str());
3213           str = mputprintf(str, "%s = %s;\n", name, tmp_id_str);
3214         } else {
3215           str = mputprintf(str, "%s = %s;\n", name, expr.expr);
3216         }
3217       }
3218       Code::free_expr(&expr);
3219     }
3220     return str;
3221   }
3222
3223   char *Template::generate_code_init_invoke(char *str, const char *name)
3224   {
3225     expression_struct expr;
3226     Code::init_expr(&expr);
3227     expr.expr = mputprintf(expr.expr, "%s = ", name);
3228     generate_code_expr_invoke(&expr);
3229     return Code::merge_free_expr(str, &expr);
3230   }
3231
3232   char *Template::generate_rearrange_init_code_refd(char *str,
3233     expression_struct *expr)
3234   {
3235     /** Initially we can assume that:
3236      *  - this is a referenced template and a part of a non-parameterized
3237      *    template
3238      *  - u.ref.ref points to (a field of) a non-parameterized template within
3239      *    the same module as \a this.
3240      *  - this ensures that the do-while loop will run at least twice (i.e. the
3241      *    first continue statement will be reached in the first iteration) */
3242     stack<FieldOrArrayRef> refstack;
3243     Template *t = this;
3244     // first try to find the smallest dependent template
3245     for ( ; ; ) {
3246       if (t->templatetype == TEMPLATE_REFD) {
3247         Common::Assignment *ass = t->u.ref.ref->get_refd_assignment();
3248         /** Don't follow the reference if:
3249          *  - the referenced definition is not a template
3250          *  - the referenced template is parameterized or
3251          *  - the referenced template is in different module */
3252         if (ass->get_asstype() == Common::Assignment::A_TEMPLATE &&
3253           ass->get_FormalParList() == 0 &&
3254           ass->get_my_scope()->get_scope_mod_gen() ==
3255             my_scope->get_scope_mod_gen()) {
3256           // accumulate the sub-references of the referred reference
3257           FieldOrArrayRefs *subrefs = t->u.ref.ref->get_subrefs();
3258           if (subrefs) {
3259             for (size_t i = subrefs->get_nof_refs(); i > 0; i--)
3260               refstack.push(subrefs->get_ref(i - 1));
3261           }
3262           // jump to the referred top-level template
3263           t = ass->get_Template();
3264           // start the iteration from the beginning
3265           continue;
3266           // stop otherwise: the reference cannot be followed
3267         } else break;
3268       }
3269       // stop if there are no sub-references
3270       if (refstack.empty()) break;
3271       // take the topmost sub-reference
3272       FieldOrArrayRef *subref = refstack.top();
3273       if (subref->get_type() == FieldOrArrayRef::FIELD_REF) {
3274         if (t->templatetype != NAMED_TEMPLATE_LIST) break;
3275         // the field reference can be followed
3276         t = t->u.named_templates->get_nt_byName(*subref->get_id())
3277           ->get_template();
3278       } else {
3279         // trying to follow an array reference
3280         if (t->templatetype != TEMPLATE_LIST) break;
3281         Value *array_index = subref->get_val()->get_value_refd_last();
3282         if (array_index->get_valuetype() != Value::V_INT) break;
3283         // the index is available at compilation time
3284         Int index = array_index->get_val_Int()->get_val();
3285         // index transformation in case of arrays
3286         if (t->my_governor->get_typetype() == Type::T_ARRAY)
3287           index -= t->my_governor->get_dimension()->get_offset();
3288         t = t->get_listitem_byIndex(index);
3289       }
3290       // the topmost sub-reference was processed
3291       // it can be erased from the stack
3292       refstack.pop();
3293     }
3294     // the smallest dependent template is now in t
3295     // generate the initializer sequence for t
3296     str = t->generate_code_init(str, t->get_lhs_name().c_str());
3297     // the equivalent C++ code of the referenced template is composed of the
3298     // genname of t and the remained sub-references in refstack
3299     expr->expr = mputstr(expr->expr, t->get_genname_own(my_scope).c_str());
3300     while (!refstack.empty()) {
3301       FieldOrArrayRef *subref = refstack.pop();
3302       if (subref->get_type() == FieldOrArrayRef::FIELD_REF) {
3303         expr->expr = mputprintf(expr->expr, ".%s()",
3304           subref->get_id()->get_name().c_str());
3305       } else {
3306         expr->expr = mputc(expr->expr, '[');
3307         subref->get_val()->generate_code_expr(expr);
3308         expr->expr = mputc(expr->expr, ']');
3309       }
3310     }
3311     return str;
3312   }
3313
3314   bool Template::compile_time() const
3315   {
3316     switch (templatetype) {
3317     case ALL_FROM:
3318     case VALUE_LIST_ALL_FROM:
3319       return false;
3320     case TEMPLATE_ERROR: /**< erroneous template */
3321     case TEMPLATE_NOTUSED: /**< not used symbol (-) */
3322     case OMIT_VALUE: /**< omit */
3323     case ANY_VALUE: /**< any value (?) */
3324     case ANY_OR_OMIT: /**< any or omit (*) */
3325     case SPECIFIC_VALUE: /**< specific value */
3326     case TEMPLATE_REFD: /**< reference to another template */
3327     case VALUE_RANGE: /**< value range match */
3328     case BSTR_PATTERN: /**< bitstring pattern */
3329     case HSTR_PATTERN: /**< hexstring pattern */
3330     case OSTR_PATTERN: /**< octetstring pattern */
3331     case CSTR_PATTERN: /**< character string pattern */
3332     case USTR_PATTERN:  /**< universal charstring pattern */
3333     case TEMPLATE_INVOKE:
3334       // Simple templates can be computed at compile time
3335       return true;
3336
3337       // "Complex" templates need to look at all elements
3338     case TEMPLATE_LIST:
3339     case VALUE_LIST:
3340     case COMPLEMENTED_LIST:
3341     case SUPERSET_MATCH:
3342     case SUBSET_MATCH:
3343     case PERMUTATION_MATCH:
3344       for (size_t i = 0; i < u.templates->get_nof_ts(); i++)
3345         if (u.templates->get_t_byIndex(i)->compile_time()) continue;
3346         else return false;
3347       return true;
3348     case NAMED_TEMPLATE_LIST:
3349       for (size_t i = 0; i < u.named_templates->get_nof_nts(); i++)
3350         if (!u.named_templates->get_nt_byIndex(i)->get_template()->compile_time())
3351           return false;
3352       return true;
3353     case INDEXED_TEMPLATE_LIST:
3354       for (size_t i = 0; i <u.indexed_templates->get_nof_its(); i++)
3355         if (!u.indexed_templates->get_it_byIndex(i)->get_template()->compile_time())
3356           return false;
3357       return true;
3358     }
3359
3360     return true; // not reached
3361   }
3362
3363   char *Template::generate_code_init_seof(char *str, const char *name)
3364   {
3365     switch (templatetype) {
3366     case TEMPLATE_LIST: {
3367       size_t nof_ts = u.templates->get_nof_ts();
3368       if (nof_ts == 0) {
3369         str = mputprintf(str, "%s = NULL_VALUE;\n", name);
3370         break;
3371       }
3372
3373       // nof_ts > 0
3374       Type *t_last = my_governor->get_type_refd_last();
3375       Int index_offset;
3376       if (t_last->get_typetype() == Type::T_ARRAY) {
3377         // take the start index from the array dimension
3378         index_offset = t_last->get_dimension()->get_offset();
3379       } else {
3380         // indexing always starts from zero
3381         index_offset = 0;
3382       }
3383
3384       const string& oftype_name =
3385         t_last->get_ofType()->get_genname_template(my_scope);
3386       const char *oftype_name_str = oftype_name.c_str();
3387
3388       ReferenceChain refch (this, "While searching template");
3389       if (!flattened || my_scope->get_statementblock_scope()) { // this "if" may be redundant if all non-var templates are flattened
3390         str = mputstr(str, "// this is a var template\n");
3391
3392         if (compile_time()) goto compile_time;
3393         // run-time, variable sized init
3394
3395         // This is a record-of var template, like this:
3396         // var template rec_of_int vt_r := {
3397         //   1, 2, 3, permutation(10, all from x, 20), 4, 5 }
3398         //   ^^^^^^^--- these ------------------------^^^^^
3399         //   are known at compile time, but the length of the "all from"
3400         //   is only known at run time.
3401         // Collect the indices where there is an "all from".
3402         dynamic_array<int> variables;
3403         size_t fixed_part = 0;
3404         if (has_permutation) {
3405           for (size_t i = 0; i < nof_ts; i++) {
3406             Template *t = u.templates->get_t_byIndex(i);
3407             if (t->templatetype == PERMUTATION_MATCH) {
3408               size_t num_p = t->u.templates->get_nof_ts();
3409               // t->u.templates is 2: "hello" and all from ...
3410               for (size_t j = 0; j < num_p; ++j) {
3411                 Template *subt = t->u.templates->get_t_byIndex(j);
3412                 if (subt->templatetype == ALL_FROM) {
3413                   variables.add(j);
3414                 }
3415                 else fixed_part++;
3416               }
3417             }
3418             else fixed_part++;
3419           }
3420
3421           char* str_preamble = 0;
3422           char* str_set_size = mputprintf(0, "%s.set_size(%lu", name,
3423             (unsigned long)fixed_part);
3424
3425           // variable part
3426           for (size_t i = 0; i < nof_ts; i++) {
3427             Template *t = u.templates->get_t_byIndex(i);
3428             for (size_t k = 0, v = variables.size(); k < v; ++k) {
3429               if (t->templatetype != PERMUTATION_MATCH) continue; // ?? really nothing to do ??
3430               Template *subt = t->u.templates->get_t_byIndex(variables[k]);
3431               if (subt->templatetype == ALL_FROM) {
3432                 Value *refv = subt->u.all_from->u.specific_value;
3433                 // don't call get_Value(), it rips out the value from the template
3434
3435                 if (refv->get_valuetype()!=Value::V_REFD) FATAL_ERROR("%s", __FUNCTION__);
3436                 Common::Reference  *ref = refv->get_reference();
3437                 FieldOrArrayRefs   *subrefs = ref->get_subrefs();
3438                 Common::Assignment *ass = ref->get_refd_assignment();
3439
3440                 str_set_size = mputstrn(str_set_size, " + ", 3);
3441
3442                 Ref_pard* ref_pard = dynamic_cast<Ref_pard*>(ref);
3443                 if (ref_pard) {
3444                   // in case of parametrised references:
3445                   //  - temporary parameters need to be declared (stored in str_preamble)
3446                   //  - the same temporary needs to be used at each call (generate_code_cached call)
3447                   expression_struct expr;
3448                   Code::init_expr(&expr);
3449
3450                   ref_pard->generate_code_cached(&expr);
3451                   str_set_size = mputprintf(str_set_size, "%s", expr.expr);
3452                   if (expr.preamble)
3453                     str_preamble = mputstr(str_preamble, expr.preamble);
3454
3455                   Code::free_expr(&expr);
3456                 }
3457                 else {
3458                   str_set_size = mputstr (str_set_size, ass->get_id().get_name().c_str());
3459                   if (subrefs) {
3460                     expression_struct expr;
3461                     Code::init_expr(&expr);
3462
3463                     subrefs->generate_code(&expr, ass);
3464                     str_set_size = mputprintf(str_set_size, "%s", expr.expr);
3465
3466                     Code::free_expr(&expr);
3467                   }
3468                 }
3469
3470                 switch(ass->get_asstype()) {
3471                 case Common::Assignment::A_CONST:
3472                 case Common::Assignment::A_EXT_CONST:
3473                 case Common::Assignment::A_MODULEPAR:
3474                 case Common::Assignment::A_VAR:
3475                 case Common::Assignment::A_PAR_VAL_IN:
3476                 case Common::Assignment::A_PAR_VAL_OUT:
3477                 case Common::Assignment::A_PAR_VAL_INOUT:
3478                 case Common::Assignment::A_FUNCTION_RVAL:
3479                 case Common::Assignment::A_EXT_FUNCTION_RVAL:
3480                   if (ass->get_Type()->field_is_optional(subrefs)) {
3481                     str_set_size = mputstrn(str_set_size, "()", 2);
3482                   }
3483                   break;
3484                 default:
3485                   break;
3486                 }
3487
3488                 str_set_size = mputstr(str_set_size, ".n_elem()");
3489               }
3490             }
3491           }
3492
3493           str = mputstr(str, str_preamble);
3494           str = mputstr(str, str_set_size);
3495
3496           Free(str_preamble);
3497           Free(str_set_size);
3498
3499           str = mputstrn(str, ");\n", 3); // finally done set_size
3500
3501           size_t index = 0;
3502           string skipper, hopper;
3503           for (size_t i = 0; i < nof_ts; i++) {
3504             Template *t = u.templates->get_t_byIndex(i);
3505             switch (t->templatetype) {
3506             case ALL_FROM: {
3507               break; }
3508             case PERMUTATION_MATCH: {
3509               size_t nof_perm_ts = t->u.templates->get_nof_ts();
3510               for (size_t j = 0; j < nof_perm_ts; j++) {
3511                 Int ix(index_offset + index + j);
3512                 Template *permut_elem = t->u.templates->get_t_byIndex(j);
3513                 if (permut_elem->templatetype == ALL_FROM) {
3514                   expression_struct expr;
3515                   Code::init_expr(&expr);
3516                   switch (permut_elem->u.all_from->templatetype) {
3517                   case SPECIFIC_VALUE: {
3518                     Value *spec = permut_elem->u.all_from->u.specific_value;
3519                     switch (spec->get_valuetype()) {
3520                     case Common::Value::V_REFD: {
3521                       Common::Reference  *ref = spec->get_reference();
3522
3523                       Ref_pard* ref_pard = dynamic_cast<Ref_pard*>(ref);
3524                       if (ref_pard)
3525                         ref_pard->generate_code_cached(&expr);
3526                       else
3527                         ref->generate_code(&expr);
3528
3529                       Common::Assignment* ass = ref->get_refd_assignment();
3530                       switch(ass->get_asstype()) {
3531                       case Common::Assignment::A_CONST:
3532                       case Common::Assignment::A_EXT_CONST:
3533                       case Common::Assignment::A_MODULEPAR:
3534                       case Common::Assignment::A_VAR:
3535                       case Common::Assignment::A_PAR_VAL_IN:
3536                       case Common::Assignment::A_PAR_VAL_OUT:
3537                       case Common::Assignment::A_PAR_VAL_INOUT:
3538                       case Common::Assignment::A_FUNCTION_RVAL:
3539                       case Common::Assignment::A_EXT_FUNCTION_RVAL:
3540                         if (ass->get_Type()->field_is_optional(ref->get_subrefs())) {
3541                           expr.expr = mputstrn(expr.expr, "()", 2);
3542                         }
3543                         break;
3544                       default:
3545                         break;
3546                       }
3547
3548                       break; }
3549                     default:
3550                       FATAL_ERROR("vtype %d", spec->get_valuetype());
3551                       break;
3552                     }
3553                     break; }
3554
3555
3556                   default:
3557                     FATAL_ERROR("ttype %d", permut_elem->u.all_from->templatetype);
3558                     break;
3559                   }
3560                   str = mputprintf(str,
3561                     "for (int i_i = 0, i_lim = %s.n_elem(); i_i < i_lim; ++i_i) {\n",
3562                     expr.expr);
3563
3564                   str = permut_elem->generate_code_init_seof_element(str, name,
3565                     (Int2string(ix) + skipper + " + i_i").c_str(),
3566                     oftype_name_str);
3567
3568                   str = mputstrn(str, "}\n", 2);
3569                   skipper += "-1+";
3570                   skipper += expr.expr;
3571                   skipper += ".n_elem() /* 3005 */ ";
3572                   Code::free_expr(&expr);
3573                 }
3574                 else {
3575                   str = permut_elem->generate_code_init_seof_element(str, name,
3576                     (Int2string(ix) + skipper).c_str(), oftype_name_str);
3577                 }
3578               }
3579               // do not consider index_offset in case of permutation indicators
3580               str = mputprintf(str, "%s.add_permutation(%lu%s, %lu%s);\n", name,
3581                 (unsigned long)index,                     hopper.c_str(),
3582                 (unsigned long)(index + nof_perm_ts - 1), skipper.c_str());
3583               hopper = skipper;
3584               t->set_code_generated();
3585               index += nof_perm_ts;
3586               break; }
3587
3588             default:
3589               str = t->generate_code_init_seof_element(str, name,
3590                 (Int2string(index_offset + index) + skipper).c_str(), oftype_name_str);
3591               // no break
3592             case TEMPLATE_NOTUSED:
3593               index++;
3594               break;
3595             }
3596           }
3597
3598           break;
3599
3600         }
3601
3602
3603         if (!has_permutation && has_allfrom()) {
3604           for (size_t i = 0; i < nof_ts; i++) {
3605             Template *t = u.templates->get_t_byIndex(i);
3606             if (t->templatetype == ALL_FROM) {
3607               variables.add(i);
3608             }
3609             else {
3610               fixed_part++;
3611             }
3612           }
3613           char* str_preamble = 0;
3614           char* str_set_size = mputprintf(0, "%s.set_size(%lu", name,
3615             (unsigned long)fixed_part);
3616
3617          // variable part
3618         for (size_t i = 0; i < nof_ts; i++) {
3619           Template *t = u.templates->get_t_byIndex(i);
3620           for (size_t k = 0, v = variables.size(); k < v; ++k) {
3621             if (t->templatetype == ALL_FROM) {
3622               Value *refv = t->u.all_from->u.specific_value;
3623               // don't call get_Value(), it rips out the value from the template
3624               if (refv->get_valuetype()!=Value::V_REFD) FATAL_ERROR("%s", __FUNCTION__);
3625               Common::Reference  *ref = refv->get_reference();
3626               FieldOrArrayRefs   *subrefs = ref->get_subrefs();
3627               Common::Assignment *ass = ref->get_refd_assignment();
3628               str_set_size = mputstrn(str_set_size, " + ", 3);
3629               Ref_pard* ref_pard = dynamic_cast<Ref_pard*>(ref);
3630               if (ref_pard) {
3631                  // in case of parametrised references:
3632                  //  - temporary parameters need to be declared (stored in str_preamble)
3633                  //  - the same temporary needs to be used at each call (generate_code_cached call)
3634                 expression_struct expr;
3635                 Code::init_expr(&expr);
3636
3637                 ref_pard->generate_code_cached(&expr);
3638                 str_set_size = mputprintf(str_set_size, "%s", expr.expr);
3639                 if (expr.preamble)
3640                   str_preamble = mputstr(str_preamble, expr.preamble);
3641                 Code::free_expr(&expr);
3642               }
3643               else {
3644                 str_set_size = mputstr (str_set_size, ass->get_id().get_name().c_str());
3645                 if (subrefs) {
3646                   expression_struct expr;
3647                   Code::init_expr(&expr);
3648                   subrefs->generate_code(&expr, ass);
3649                   str_set_size = mputprintf(str_set_size, "%s", expr.expr);
3650                   Code::free_expr(&expr);
3651                 }
3652               }
3653
3654               switch(ass->get_asstype()) {
3655               case Common::Assignment::A_CONST:
3656               case Common::Assignment::A_EXT_CONST:
3657               case Common::Assignment::A_MODULEPAR:
3658               case Common::Assignment::A_VAR:
3659               case Common::Assignment::A_PAR_VAL_IN:
3660               case Common::Assignment::A_PAR_VAL_OUT:
3661               case Common::Assignment::A_PAR_VAL_INOUT:
3662               case Common::Assignment::A_FUNCTION_RVAL:
3663               case Common::Assignment::A_EXT_FUNCTION_RVAL:
3664                 if (ass->get_Type()->field_is_optional(subrefs)) {
3665                   str_set_size = mputstrn(str_set_size, "()", 2);
3666                 }
3667                 break;
3668               default:
3669                 break;
3670               }
3671
3672               str_set_size = mputstr(str_set_size, ".n_elem()");
3673             }
3674           }
3675         }
3676         str = mputstr(str, str_preamble);
3677         str = mputstr(str, str_set_size);
3678         Free(str_preamble);
3679         Free(str_set_size);
3680         str = mputstrn(str, ");\n", 3); // finally done set_size
3681
3682         size_t index = 0;
3683         string skipper;
3684         for (size_t i = 0; i < nof_ts; i++) {
3685           Template *t = u.templates->get_t_byIndex(i);
3686           Int ix(index_offset + i);
3687           switch (t->templatetype) {
3688           case ALL_FROM: {
3689               expression_struct expr;
3690               Code::init_expr(&expr);
3691               switch (t->u.all_from->templatetype) {
3692                 case SPECIFIC_VALUE: {
3693                   Value *spec = t->u.all_from->u.specific_value;
3694                   switch (spec->get_valuetype()) {
3695                   case Common::Value::V_REFD: {
3696                     Common::Reference  *ref = spec->get_reference();
3697                     Ref_pard* ref_pard = dynamic_cast<Ref_pard*>(ref);
3698                     if (ref_pard)
3699                       ref_pard->generate_code_cached(&expr);
3700                     else
3701                       ref->generate_code(&expr);
3702
3703                     Common::Assignment* ass = ref->get_refd_assignment();
3704                     switch(ass->get_asstype()) {
3705                     case Common::Assignment::A_CONST:
3706                     case Common::Assignment::A_EXT_CONST:
3707                     case Common::Assignment::A_MODULEPAR:
3708                     case Common::Assignment::A_VAR:
3709                     case Common::Assignment::A_PAR_VAL_IN:
3710                     case Common::Assignment::A_PAR_VAL_OUT:
3711                     case Common::Assignment::A_PAR_VAL_INOUT:
3712                     case Common::Assignment::A_FUNCTION_RVAL:
3713                     case Common::Assignment::A_EXT_FUNCTION_RVAL:
3714                       if (ass->get_Type()->field_is_optional(ref->get_subrefs())) {
3715                         expr.expr = mputstrn(expr.expr, "()", 2);
3716                       }
3717                       break;
3718                     default:
3719                       break;
3720                     }
3721
3722                     break; }
3723                   default:
3724                     FATAL_ERROR("vtype %d", spec->get_valuetype());
3725                     break;
3726                   }
3727                   break; }
3728                 default: {
3729                   FATAL_ERROR("ttype %d", t->u.all_from->templatetype);
3730                   break; }
3731               }
3732               str = mputprintf(str,
3733                 "for (int i_i = 0, i_lim = %s.n_elem(); i_i < i_lim; ++i_i) {\n",
3734                 expr.expr);
3735               str = t->generate_code_init_seof_element(str, name,
3736                 (Int2string(ix) + skipper + " + i_i").c_str(),
3737                 oftype_name_str);
3738               str = mputstrn(str, "}\n", 2);
3739               skipper += "-1+";
3740               skipper += expr.expr;
3741               skipper += ".n_elem() ";
3742               Code::free_expr(&expr);
3743               t->set_code_generated();
3744               ++index;
3745               break; }
3746             default: {
3747                str = t->generate_code_init_seof_element(str, name,
3748                  (Int2string(index_offset + index) + skipper).c_str(), oftype_name_str);
3749                // no break
3750             case TEMPLATE_NOTUSED:
3751                ++index;
3752                break; }
3753             }
3754           }
3755         }
3756
3757         // else carry on
3758       }
3759 compile_time:
3760       // setting the size first
3761       if (!has_allfrom())
3762         str = mputprintf(str, "%s.set_size(%lu);\n", name, (unsigned long) get_nof_listitems());
3763       // determining the index offset based on the governor
3764
3765       size_t index = 0;
3766       for (size_t i = 0; i < nof_ts; i++) {
3767         Template *t = u.templates->get_t_byIndex(i);
3768         switch (t->templatetype) {
3769         case PERMUTATION_MATCH: {
3770           size_t nof_perm_ts = t->u.templates->get_nof_ts();
3771           for (size_t j = 0; j < nof_perm_ts; j++) {
3772             Int ix(index_offset + index + j);
3773             str = t->u.templates->get_t_byIndex(j)
3774                   ->generate_code_init_seof_element(str, name,
3775                     Int2string(ix).c_str(), oftype_name_str);
3776           }
3777           // do not consider index_offset in case of permutation indicators
3778           str = mputprintf(str, "%s.add_permutation(%lu, %lu);\n", name,
3779             (unsigned long)index, (unsigned long) (index + nof_perm_ts - 1));
3780           t->set_code_generated();
3781           index += nof_perm_ts;
3782           break; }
3783
3784         default:
3785           str = t->generate_code_init_seof_element(str, name,
3786             Int2string(index_offset + index).c_str(), oftype_name_str);
3787           // no break
3788         case ALL_FROM:
3789         case TEMPLATE_NOTUSED:
3790           index++;
3791         }
3792       }
3793       break; }
3794     case INDEXED_TEMPLATE_LIST: {
3795       size_t nof_its = u.indexed_templates->get_nof_its();
3796       if (nof_its > 0) {
3797         Type *t_last = my_governor->get_type_refd_last();
3798         const string& oftype_name =
3799           t_last->get_ofType()->get_genname_template(my_scope);
3800         const char *oftype_name_str = oftype_name.c_str();
3801         // There's no need to generate a set_size call here.  To do that, we
3802         // should know the size of the base template, which is not available
3803         // from here.
3804         for (size_t i = 0; i < nof_its; i++) {
3805           IndexedTemplate *it = u.indexed_templates->get_it_byIndex(i);
3806           const string& tmp_id_1 = get_temporary_id();
3807           str = mputstr(str, "{\n");
3808           Value *index = (it->get_index()).get_val();
3809           if (index->get_valuetype() != Value::V_INT) {
3810             const string& tmp_id_2 = get_temporary_id();
3811             str = mputprintf(str, "int %s;\n", tmp_id_2.c_str());
3812             str = index->generate_code_init(str, tmp_id_2.c_str());
3813             str = mputprintf(str, "%s& %s = %s[%s];\n", oftype_name_str,
3814                     tmp_id_1.c_str(), name, tmp_id_2.c_str());
3815           } else {
3816               str = mputprintf(str, "%s& %s = %s[%s];\n", oftype_name_str,
3817                       tmp_id_1.c_str(), name,
3818                   Int2string(index->get_val_Int()->get_val()).c_str());
3819           }
3820           str = it->get_template()->generate_code_init(str, tmp_id_1.c_str());
3821           str = mputstr(str, "}\n");
3822         }
3823       } else {
3824         // It seems to be impossible in this case.
3825         str = mputprintf(str, "%s = NULL_VALUE;\n", name);
3826       }
3827       break; }
3828     default:
3829       FATAL_ERROR("Template::generate_code_init_seof()");
3830       return NULL;
3831     }
3832     return str;
3833   }
3834
3835   char *Template::generate_code_init_seof_element(char *str, const char *name,
3836     const char* index, const char *element_type_genname)
3837   {
3838     if (needs_temp_ref()) {
3839       const string& tmp_id = get_temporary_id();
3840       str = mputprintf(str, "{\n"
3841         "%s& %s = %s[%s];\n",
3842         element_type_genname, tmp_id.c_str(), name, index);
3843       str = generate_code_init(str, tmp_id.c_str());
3844       str = mputstr(str, "}\n");
3845     } else {
3846       char *embedded_name = mprintf("%s[%s]", name, index);
3847       str = generate_code_init(str, embedded_name);
3848       Free(embedded_name);
3849     }
3850     return str;
3851   }
3852
3853   char *Template::generate_code_init_all_from(char *str, const char *name)
3854   {
3855     // we are ALL_FROM, hence u.all_from
3856     switch (u.all_from->templatetype) {
3857     case SPECIFIC_VALUE: {
3858       Value *spec = u.all_from->u.specific_value;
3859       switch (spec->get_valuetype()) {
3860       case Common::Value::V_REFD: {
3861         Common::Reference  *ref = spec->get_reference();
3862         expression_struct expr;
3863         Code::init_expr(&expr);
3864         Ref_pard* ref_pard = dynamic_cast<Ref_pard*>(ref);
3865         if (ref_pard)
3866           ref_pard->generate_code_cached(&expr);
3867         else
3868           ref->generate_code(&expr);
3869
3870         Common::Assignment* ass = ref->get_refd_assignment();
3871         switch(ass->get_asstype()) {
3872         case Common::Assignment::A_CONST:
3873         case Common::Assignment::A_EXT_CONST:
3874         case Common::Assignment::A_MODULEPAR:
3875         case Common::Assignment::A_VAR:
3876         case Common::Assignment::A_PAR_VAL_IN:
3877         case Common::Assignment::A_PAR_VAL_OUT:
3878         case Common::Assignment::A_PAR_VAL_INOUT:
3879         case Common::Assignment::A_FUNCTION_RVAL:
3880         case Common::Assignment::A_EXT_FUNCTION_RVAL:
3881           if (ass->get_Type()->field_is_optional(ref->get_subrefs())) {
3882             expr.expr = mputstrn(expr.expr, "()", 2);
3883           }
3884           break;
3885         default:
3886           break;
3887         }
3888
3889         str = mputprintf(str, "%s = %s[i_i];\n", name, expr.expr);
3890         // The caller will have to provide the for cycle with this variable
3891         Code::free_expr(&expr);
3892         break; }
3893       default:
3894         break;
3895       }
3896       break; }
3897     default:
3898       break;
3899     }
3900     return str;
3901   }
3902
3903   char *Template::generate_code_init_all_from_list(char *str, const char *name)
3904   {
3905     // FIXME: this is the third instance
3906     expression_struct expr;
3907     Code::init_expr(&expr);
3908     switch (u.all_from->templatetype) {
3909     case SPECIFIC_VALUE: {
3910       Value *spec = u.all_from->u.specific_value;
3911       switch (spec->get_valuetype()) {
3912       case Common::Value::V_REFD: {
3913         Common::Reference  *ref = spec->get_reference();
3914         Ref_pard* ref_pard = dynamic_cast<Ref_pard*>(ref);
3915         if (ref_pard)
3916           ref_pard->generate_code_cached(&expr);
3917         else
3918           ref->generate_code(&expr);
3919         break; }
3920       default:
3921         FATAL_ERROR("vtype %d", spec->get_valuetype());
3922         break;
3923       }
3924       break; }
3925
3926     default:
3927       FATAL_ERROR("ttype %d", u.all_from->templatetype);
3928       break;
3929     }
3930
3931     if (expr.preamble)
3932      str = mputstr(str, expr.preamble);
3933
3934     str = mputprintf(str,
3935       "%s.set_type(VALUE_LIST, %s.n_elem());\n"
3936       "for (int i_i = 0, i_lim = %s.n_elem(); i_i < i_lim; ++i_i) {\n",
3937       name,
3938       expr.expr,
3939       expr.expr);
3940     string embedded_name(name);
3941     embedded_name += ".list_item(i_i)";
3942     str = generate_code_init_all_from(str, embedded_name.c_str());
3943     str = mputstrn(str, "}\n", 2);
3944
3945     Code::free_expr(&expr);
3946     return str;
3947   }
3948
3949   char *Template::generate_code_init_se(char *str, const char *name)
3950   { // named template list
3951     size_t nof_nts = u.named_templates->get_nof_nts();
3952     Type *type = my_governor->get_type_refd_last();
3953     if (type->get_nof_comps() > 0) {
3954       for (size_t i = 0; i < nof_nts; i++) {
3955         NamedTemplate *nt = u.named_templates->get_nt_byIndex(i);
3956         const Identifier& fieldname = nt->get_name();
3957         const char *fieldname_str = 0;
3958         string at("AT_");
3959         if (type->get_typetype()==Type::T_ANYTYPE) {
3960           at += fieldname.get_name();
3961           fieldname_str = at.c_str();
3962         }
3963         else {
3964           fieldname_str = fieldname.get_name().c_str();
3965         }
3966         Template *t = nt->get_template();
3967         if (t->needs_temp_ref()) {
3968           Type *field_type;
3969           if (type->get_typetype() == Type::T_SIGNATURE) {
3970             field_type = type->get_signature_parameters()
3971               ->get_param_byName(fieldname)->get_type();
3972           } else {
3973             field_type = type->get_comp_byName(fieldname)->get_type();
3974           }
3975           const string& tmp_id = get_temporary_id();
3976           const char *tmp_id_str = tmp_id.c_str();
3977           str = mputprintf(str, "{\n"
3978             "%s& %s = %s.%s();\n",
3979             field_type->get_genname_template(my_scope).c_str(), tmp_id_str,
3980             name, fieldname_str);
3981           str = t->generate_code_init(str, tmp_id_str);
3982           str = mputstr(str, "}\n");
3983         } else {
3984           char *embedded_name = mprintf("%s.%s()", name, fieldname_str);
3985           str = t->generate_code_init(str, embedded_name);
3986           Free(embedded_name);
3987         }
3988       }
3989     } else {
3990       str = mputprintf(str, "%s = NULL_VALUE;\n", name);
3991     }
3992     return str;
3993   }
3994
3995   char *Template::generate_code_init_list(char *str, const char *name,
3996      bool is_complemented) // VALUE_LIST or COMPLEMENTED_LIST
3997   {
3998     size_t nof_ts = u.templates->get_nof_ts();
3999     const string& type_name = my_governor->get_genname_template(my_scope);
4000     const char *type_name_str = type_name.c_str();
4001
4002     dynamic_array<int> variables;
4003     size_t fixed_part = 0;
4004     for (size_t i = 0; i < nof_ts; ++i) {
4005       Template *t = u.templates->get_t_byIndex(i);
4006       if (t->templatetype == ALL_FROM) {
4007         variables.add(i);
4008       }
4009       else ++fixed_part;
4010     }
4011
4012     if (variables.size() > 0) {
4013       char* str_preamble = 0;
4014       char* str_set_type = mprintf("%s.set_type(%s, %lu", name,
4015         (is_complemented ? "COMPLEMENTED_LIST" : "VALUE_LIST"),
4016         (unsigned long)fixed_part);
4017       // The code to compute the number of elements at run time (the variable part).
4018       // This is the sum of sizes of "all from"s.
4019       for (size_t v = 0, vs = variables.size(); v < vs; ++v) {
4020         Template *vt = u.templates->get_t_byIndex(variables[v]);
4021         if (vt->templatetype != ALL_FROM) FATAL_ERROR("must be ALL_FROM");
4022         if (vt->u.all_from->templatetype != SPECIFIC_VALUE) FATAL_ERROR("not value");
4023         Value *val = vt->u.all_from->u.specific_value;
4024         if (val->get_valuetype() != Value::V_REFD) FATAL_ERROR("ref expected from val");
4025         Common::Reference  *ref = val->get_reference();
4026         FieldOrArrayRefs   *subrefs = ref->get_subrefs();
4027         Common::Assignment *ass = ref->get_refd_assignment();
4028         if (!ass) FATAL_ERROR("Could not grab ass!");
4029
4030         str_set_type = mputstrn(str_set_type, " + ", 3);
4031
4032         Ref_pard* ref_pard = dynamic_cast<Ref_pard*>(ref);
4033         if (ref_pard) {
4034           // in case of parametrised references:
4035           //  - temporary parameters need to be declared (stored in str_preamble)
4036           //  - the same temporary needs to be used at each call (generate_code_cached call)
4037           expression_struct expr;
4038           Code::init_expr(&expr);
4039
4040           ref_pard->generate_code_cached(&expr);
4041           str_set_type = mputprintf(str_set_type, "%s", expr.expr);
4042           if (expr.preamble)
4043             str_preamble = mputstr(str_preamble, expr.preamble);
4044
4045           Code::free_expr(&expr);
4046         }
4047         else {
4048           str_set_type = mputstr (str_set_type, ass->get_id().get_name().c_str());
4049           if (subrefs) {
4050             expression_struct expr;
4051             Code::init_expr(&expr);
4052
4053             subrefs->generate_code(&expr, ass);
4054             str_set_type = mputprintf(str_set_type, "%s", expr.expr);
4055
4056             Code::free_expr(&expr);
4057           }
4058         }
4059
4060         switch(ass->get_asstype()) {
4061         case Common::Assignment::A_CONST:
4062         case Common::Assignment::A_EXT_CONST:
4063         case Common::Assignment::A_MODULEPAR:
4064         case Common::Assignment::A_VAR:
4065         case Common::Assignment::A_PAR_VAL_IN:
4066         case Common::Assignment::A_PAR_VAL_OUT:
4067         case Common::Assignment::A_PAR_VAL_INOUT:
4068         case Common::Assignment::A_FUNCTION_RVAL:
4069         case Common::Assignment::A_EXT_FUNCTION_RVAL:
4070           if (ass->get_Type()->field_is_optional(subrefs)) {
4071             str_set_type = mputstrn(str_set_type, "()", 2);
4072           }
4073           break;
4074         default:
4075           break;
4076         }
4077
4078         str_set_type = mputstr(str_set_type, ".n_elem()");
4079       }
4080
4081       str = mputstr(str, str_preamble);
4082       str = mputstr(str, str_set_type);
4083
4084       Free(str_preamble);
4085       Free(str_set_type);
4086
4087       str = mputstrn(str, ");\n", 3);
4088
4089       string shifty; // contains the expression used to calculate
4090       // the size increase due to the runtime expansion of "all from".
4091       // In nof_ts, each "all from" appears as 1, but actually contributes
4092       // more. So the increase (by which all elements after the "all from"
4093       // are shifted) is:    target_of_all_from.n_elem()-1
4094       // This needs to be accumulated for each "all from".
4095       for (size_t vi = 0; vi < nof_ts; ++vi) {
4096         Template *t = u.templates->get_t_byIndex(vi);
4097         switch (t->templatetype) {
4098         case VALUE_LIST_ALL_FROM:
4099           FATAL_ERROR("VALUE_LIST_ALL_FROM not handled");
4100         case ALL_FROM: {
4101           expression_struct expr;
4102           Code::init_expr(&expr);
4103           // variable one
4104           switch (t->u.all_from->templatetype) {
4105           case SPECIFIC_VALUE: {
4106             Value *sv = t->u.all_from->u.specific_value;
4107             switch (sv->get_valuetype()) {
4108             case Value::V_REFD: {
4109               Common::Reference *ref = sv->get_reference();
4110               Ref_pard* ref_pard = dynamic_cast<Ref_pard*>(ref);
4111               if (ref_pard)
4112                 ref_pard->generate_code_cached(&expr);
4113               else
4114                 ref->generate_code(&expr);
4115
4116               Common::Assignment* ass = ref->get_refd_assignment();
4117               switch(ass->get_asstype()) {
4118               case Common::Assignment::A_CONST:
4119               case Common::Assignment::A_EXT_CONST:
4120               case Common::Assignment::A_MODULEPAR:
4121               case Common::Assignment::A_VAR:
4122               case Common::Assignment::A_PAR_VAL_IN:
4123               case Common::Assignment::A_PAR_VAL_OUT:
4124               case Common::Assignment::A_PAR_VAL_INOUT:
4125               case Common::Assignment::A_FUNCTION_RVAL:
4126               case Common::Assignment::A_EXT_FUNCTION_RVAL:
4127                 if (ass->get_Type()->field_is_optional(ref->get_subrefs())) {
4128                   expr.expr = mputstrn(expr.expr, "()", 2);
4129                 }
4130                 break;
4131               default:
4132                 break;
4133               }
4134
4135               break; }
4136
4137             default:
4138               FATAL_ERROR("VT NOT HANDLED");
4139             } // switch valuetype
4140             break; }
4141
4142           default:
4143             FATAL_ERROR("ttype not handled");
4144             break;
4145           }
4146
4147           // All local variables should contain a single underscore,
4148           // to avoid potential clashes with field names.
4149           str = mputprintf(str, "for (int i_i= 0, i_lim = %s.n_elem(); i_i < i_lim; ++i_i) {\n",
4150             expr.expr);
4151
4152           if (t->needs_temp_ref()) {
4153             // Not possible, because t->templatetype is ALL_FROM
4154             FATAL_ERROR("temp ref not handled");
4155           }
4156           char *embedded_name = mprintf("%s.list_item(%lu + i_i%s)", name,
4157             (unsigned long) vi, shifty.c_str());
4158           str = t->generate_code_init(str, embedded_name);
4159           Free(embedded_name);
4160
4161           str = mputstrn(str, "}\n", 2);
4162
4163           shifty += "-1+";
4164           shifty += expr.expr;
4165           shifty += ".n_elem() /* 3303 */ ";
4166
4167           Code::free_expr(&expr);
4168           break; }
4169
4170         default: // "fixed one"
4171           if (t->needs_temp_ref()) { // FIXME: this is copypasta from below / but may need to be changed
4172             const string& tmp_id = get_temporary_id();
4173             const char *tmp_id_str = tmp_id.c_str();
4174             str = mputprintf(str, "{\n"
4175               "%s& %s = %s.list_item(%lu);\n",
4176               type_name_str, tmp_id_str, name, (unsigned long) vi);
4177             str = t->generate_code_init(str, tmp_id_str);
4178             str = mputstr(str, "}\n");
4179           } else {
4180             char *embedded_name = mprintf("%s.list_item(%lu%s)", name,
4181               (unsigned long) vi, shifty.c_str());
4182             str = t->generate_code_init(str, embedded_name);
4183             Free(embedded_name);
4184           }
4185           break;
4186         } // switch t->templatetype
4187       }
4188     }
4189     else {
4190       str = mputprintf(str, "%s.set_type(%s, %lu);\n", name,
4191         is_complemented ? "COMPLEMENTED_LIST" : "VALUE_LIST",
4192           (unsigned long) nof_ts);
4193       for (size_t i = 0; i < nof_ts; i++) {
4194         Template *t = u.templates->get_t_byIndex(i);
4195         if (t->needs_temp_ref()) {
4196           const string& tmp_id = get_temporary_id();
4197           const char *tmp_id_str = tmp_id.c_str();
4198           str = mputprintf(str, "{\n"
4199             "%s& %s = %s.list_item(%lu);\n",
4200             type_name_str, tmp_id_str, name, (unsigned long) i);
4201           str = t->generate_code_init(str, tmp_id_str);
4202           str = mputstr(str, "}\n");
4203         } else {
4204           char *embedded_name = mprintf("%s.list_item(%lu)", name,
4205             (unsigned long) i);
4206           str = t->generate_code_init(str, embedded_name);
4207           Free(embedded_name);
4208         }
4209       }
4210     }
4211     return str;
4212   }
4213
4214   char *Template::generate_code_init_set(char *str, const char *name,
4215     bool is_superset) // SUPERSET_MATCH and SUBSET_MATCH
4216   {
4217     size_t nof_ts = u.templates->get_nof_ts();
4218     const string& oftype_name =
4219       my_governor->get_ofType()->get_genname_template(my_scope);
4220     const char *oftype_name_str = oftype_name.c_str();
4221
4222     dynamic_array<int> variables;
4223     size_t fixed_part = 0;
4224     for (size_t i = 0; i < nof_ts; ++i) {
4225       Template *t = u.templates->get_t_byIndex(i);
4226       if (t->templatetype == ALL_FROM) {
4227         variables.add(i);
4228       }
4229       else ++fixed_part;
4230     }
4231
4232     //warning("There are %lu set elements", nof_ts);
4233     if (variables.size() > 0) {
4234       char* str_preamble = 0;
4235       char* str_set_type = mputprintf(0, "%s.set_type(%s, %lu", name,
4236         is_superset ? "SUPERSET_MATCH" : "SUBSET_MATCH", (unsigned long) fixed_part);
4237
4238       for (size_t v = 0, vs = variables.size(); v < vs; ++v) {
4239         Template *vt = u.templates->get_t_byIndex(variables[v]);
4240         if (vt->templatetype != ALL_FROM) FATAL_ERROR("must be ALL_FROM");
4241         if (vt->u.all_from->templatetype != SPECIFIC_VALUE) FATAL_ERROR("not value");
4242         Value *val = vt->u.all_from->u.specific_value;
4243         if (val->get_valuetype() != Value::V_REFD) FATAL_ERROR("ref expected from val");
4244         Common::Reference  *ref = val->get_reference();
4245         FieldOrArrayRefs   *subrefs = ref->get_subrefs();
4246         Common::Assignment *ass = ref->get_refd_assignment();
4247         if (!ass) FATAL_ERROR("Could not grab ass!");
4248
4249         str_set_type = mputstrn(str_set_type, " + ", 3);
4250
4251         Ref_pard* ref_pard = dynamic_cast<Ref_pard*>(ref);
4252         if (ref_pard) {
4253           // in case of parametrised references:
4254           //  - temporary parameters need to be declared (stored in str_preamble)
4255           //  - the same temporary needs to be used at each call (generate_code_cached call)
4256           expression_struct expr;
4257           Code::init_expr(&expr);
4258
4259           ref_pard->generate_code_cached(&expr);
4260           str_set_type = mputprintf(str_set_type, "%s", expr.expr);
4261           if (expr.preamble)
4262             str_preamble = mputstr(str_preamble, expr.preamble);
4263
4264           Code::free_expr(&expr);
4265         }
4266         else {
4267           str_set_type = mputstr (str_set_type, ass->get_id().get_name().c_str());
4268           if (subrefs) {
4269             expression_struct expr;
4270             Code::init_expr(&expr);
4271
4272             subrefs->generate_code(&expr, ass);
4273             str_set_type = mputprintf(str_set_type, "%s", expr.expr);
4274
4275             Code::free_expr(&expr);
4276           }
4277         }
4278
4279         switch(ass->get_asstype()) {
4280         case Common::Assignment::A_CONST:
4281         case Common::Assignment::A_EXT_CONST:
4282         case Common::Assignment::A_MODULEPAR:
4283         case Common::Assignment::A_VAR:
4284         case Common::Assignment::A_PAR_VAL_IN:
4285         case Common::Assignment::A_PAR_VAL_OUT:
4286         case Common::Assignment::A_PAR_VAL_INOUT:
4287         case Common::Assignment::A_FUNCTION_RVAL:
4288         case Common::Assignment::A_EXT_FUNCTION_RVAL:
4289           if (ass->get_Type()->field_is_optional(subrefs)) {
4290             str_set_type = mputstrn(str_set_type, "()", 2);
4291           }
4292           break;
4293         default:
4294           break;
4295         }
4296
4297         str_set_type = mputstr(str_set_type, ".n_elem()");
4298       }
4299
4300       str = mputstr(str, str_preamble);
4301       str = mputstr(str, str_set_type);
4302
4303       Free(str_preamble);
4304       Free(str_set_type);
4305
4306       str = mputstrn(str, ");\n", 3);
4307
4308       string shifty;
4309       for (size_t i = 0; i < nof_ts; i++) {
4310         Template *t = u.templates->get_t_byIndex(i);
4311         switch (t->templatetype) {
4312         case ALL_FROM: {
4313           expression_struct expr; // FIXME copypasta from init_list above !
4314           Code::init_expr(&expr);
4315           // variable one
4316           switch (t->u.all_from->templatetype) {
4317           case SPECIFIC_VALUE: {
4318             Value *sv = t->u.all_from->u.specific_value;
4319             switch (sv->get_valuetype()) {
4320             case Value::V_REFD: {
4321               Common::Reference *ref = sv->get_reference();
4322               Ref_pard* ref_pard = dynamic_cast<Ref_pard*>(ref);
4323               if (ref_pard)
4324                 ref_pard->generate_code_cached(&expr);
4325               else
4326                 ref->generate_code(&expr);
4327
4328               Common::Assignment* ass = ref->get_refd_assignment();
4329               switch(ass->get_asstype()) {
4330               case Common::Assignment::A_CONST:
4331               case Common::Assignment::A_EXT_CONST:
4332               case Common::Assignment::A_MODULEPAR:
4333               case Common::Assignment::A_VAR:
4334               case Common::Assignment::A_PAR_VAL_IN:
4335               case Common::Assignment::A_PAR_VAL_OUT:
4336               case Common::Assignment::A_PAR_VAL_INOUT:
4337               case Common::Assignment::A_FUNCTION_RVAL:
4338               case Common::Assignment::A_EXT_FUNCTION_RVAL:
4339                 if (ass->get_Type()->field_is_optional(ref->get_subrefs())) {
4340                   expr.expr = mputstrn(expr.expr, "()", 2);
4341                 }
4342                 break;
4343               default:
4344                 break;
4345               }
4346
4347               break; }
4348
4349             default:
4350               FATAL_ERROR("VT NOT HANDLED");
4351             } // switch valuetype
4352             break; }
4353
4354           default:
4355             FATAL_ERROR("ttype not handled");
4356             break;
4357           }
4358
4359           str = mputprintf(str,
4360             "for (int i_i = 0, i_lim = %s.n_elem(); i_i < i_lim; ++i_i) {\n",
4361             expr.expr);
4362
4363           // Name for the LHS
4364           char *embedded_name = mprintf("%s.set_item(%lu%s + i_i)", name,
4365             (unsigned long) i, shifty.c_str());
4366           str = t->generate_code_init_all_from(str, embedded_name);
4367           Free(embedded_name);
4368
4369           str = mputstrn(str, "}\n", 2);
4370
4371           shifty += "-1+";
4372           shifty += expr.expr;
4373           shifty += ".n_elem() /* 3442 */";
4374           Code::free_expr(&expr);
4375           break; }
4376         case VALUE_LIST_ALL_FROM:
4377           FATAL_ERROR("Not possible");
4378           break; // not reached
4379
4380         default:
4381           if (t->needs_temp_ref()) {
4382             const string& tmp_id = get_temporary_id();
4383             const char *tmp_id_str = tmp_id.c_str();
4384             str = mputprintf(str, "{\n"
4385               "%s& %s = %s.set_item(%lu%s);\n",
4386               oftype_name_str, tmp_id_str, name, (unsigned long) i, shifty.c_str());
4387             str = t->generate_code_init(str, tmp_id_str);
4388             str = mputstr(str, "}\n");
4389           } else {
4390             char *embedded_name = mprintf("%s.set_item(%lu%s)", name,
4391               (unsigned long) i, shifty.c_str());
4392             str = t->generate_code_init(str, embedded_name);
4393             Free(embedded_name);
4394           }
4395           break;
4396         } // switch t->templatetype
4397       }
4398
4399     }
4400     else {
4401       str = mputprintf(str, "%s.set_type(%s, %lu);\n", name,
4402         is_superset ? "SUPERSET_MATCH" : "SUBSET_MATCH", (unsigned long) nof_ts);
4403       for (size_t i = 0; i < nof_ts; i++) {
4404         Template *t = u.templates->get_t_byIndex(i);
4405         if (t->needs_temp_ref()) {
4406           const string& tmp_id = get_temporary_id();
4407           const char *tmp_id_str = tmp_id.c_str();
4408           str = mputprintf(str, "{\n"
4409             "%s& %s = %s.set_item(%lu);\n",
4410             oftype_name_str, tmp_id_str, name, (unsigned long) i);
4411           str = t->generate_code_init(str, tmp_id_str);
4412           str = mputstr(str, "}\n");
4413         } else {
4414           char *embedded_name = mprintf("%s.set_item(%lu)", name,
4415             (unsigned long) i);
4416           str = t->generate_code_init(str, embedded_name);
4417           Free(embedded_name);
4418         }
4419       }
4420     }
4421     return str;
4422   }
4423
4424   void Template::generate_code_expr_invoke(expression_struct *expr)
4425   {
4426     Value *last_v = u.invoke.v->get_value_refd_last();
4427     if (last_v->get_valuetype() == Value::V_FUNCTION) {
4428       Common::Assignment *function = last_v->get_refd_fat();
4429       expr->expr = mputprintf(expr->expr, "%s(",
4430         function->get_genname_from_scope(my_scope).c_str());
4431       u.invoke.ap_list->generate_code_alias(expr,
4432         function->get_FormalParList(), function->get_RunsOnType(), false);
4433     } else {
4434       u.invoke.v->generate_code_expr_mandatory(expr);
4435       expr->expr = mputstr(expr->expr, ".invoke(");
4436       Type* gov_last = u.invoke.v->get_expr_governor_last();
4437       u.invoke.ap_list->generate_code_alias(expr, 0,
4438         gov_last->get_fat_runs_on_type(), gov_last->get_fat_runs_on_self());
4439     }
4440     expr->expr = mputc(expr->expr, ')');
4441   }
4442
4443   char *Template::rearrange_init_code_refd(char *str)
4444   {
4445     if (templatetype != TEMPLATE_REFD)
4446       FATAL_ERROR("Template::rearrange_init_code_refd()");
4447     ActualParList *parlist = u.ref.ref->get_parlist();
4448     // generate code for the templates that are used in the actual parameter
4449     // list of the reference
4450     Common::Assignment *ass = u.ref.ref->get_refd_assignment();
4451     bool rearrange = (ass->get_my_scope()->get_scope_mod_gen() ==
4452         my_scope->get_scope_mod_gen());
4453     if (parlist) str = parlist->rearrange_init_code(str, rearrange);
4454     // do nothing if the reference does not point to a template definition
4455     if (ass->get_asstype() != Common::Assignment::A_TEMPLATE) return str;
4456     // do nothing if the referenced template is in another module
4457     if (ass->get_my_scope()->get_scope_mod_gen() !=
4458         my_scope->get_scope_mod_gen()) return str;
4459     Template *t = ass->get_Template();
4460     if (parlist) {
4461       // the reference points to a parameterized template
4462       // we must perform the rearrangement for all non-parameterized templates
4463       // that are referred by the parameterized template regardless the
4464       // sub-references of u.ref.ref
4465       str = t->rearrange_init_code(str);
4466     } else {
4467       // the reference points to a non-parameterized template
4468       FieldOrArrayRefs *subrefs = u.ref.ref->get_subrefs();
4469       if (subrefs) {
4470         // we should follow the sub-references as much as we can
4471         // and perform the rearrangement for the referred field only
4472         for (size_t i = 0; i < subrefs->get_nof_refs(); i++) {
4473           FieldOrArrayRef *ref = subrefs->get_ref(i);
4474           if (ref->get_type() == FieldOrArrayRef::FIELD_REF) {
4475             // stop if the body does not have fields
4476             if (t->templatetype != NAMED_TEMPLATE_LIST) break;
4477             // get the sub-template of the referred field
4478             t = t->u.named_templates->get_nt_byName(*ref->get_id())
4479               ->get_template();
4480           } else {
4481             // stop if the body is not a list
4482             if (t->templatetype != TEMPLATE_LIST) break;
4483             Value *array_index = ref->get_val()->get_value_refd_last();
4484             // stop if the index cannot be evaluated at compile time
4485             if (array_index->get_valuetype() != Value::V_INT) break;
4486             Int index = array_index->get_val_Int()->get_val();
4487             // index transformation in case of arrays
4488             if (t->my_governor->get_typetype() == Type::T_ARRAY)
4489               index -= t->my_governor->get_dimension()->get_offset();
4490             // get the template with the given index
4491             t = t->get_listitem_byIndex(index);
4492           }
4493         }
4494       }
4495       // otherwise if the reference points to a top-level template
4496       // we should initialize its entire body
4497       str = t->generate_code_init(str, t->get_lhs_name().c_str());
4498     }
4499     return str;
4500   }
4501
4502   char *Template::rearrange_init_code_invoke(char *str)
4503   {
4504     str = u.invoke.v->rearrange_init_code(str);
4505     bool type_is_local = u.invoke.v->get_expr_governor_last()->get_my_scope()
4506       ->get_scope_mod_gen() == my_scope->get_scope_mod_gen();
4507     str = u.invoke.ap_list->rearrange_init_code(str, type_is_local);
4508     return str;
4509   }
4510
4511   bool Template::needs_temp_ref()
4512   {
4513     if (length_restriction || is_ifpresent) return true;
4514     switch (templatetype) {
4515     case OMIT_VALUE:
4516     case ANY_VALUE:
4517     case ANY_OR_OMIT:
4518     case SPECIFIC_VALUE:
4519     case TEMPLATE_REFD:
4520     case TEMPLATE_INVOKE:
4521     case BSTR_PATTERN:
4522     case HSTR_PATTERN:
4523     case OSTR_PATTERN:
4524     case CSTR_PATTERN:
4525     case USTR_PATTERN:
4526       return false;
4527     case TEMPLATE_LIST:
4528       // temporary reference is needed if the template has at least one
4529       // element (excluding not used symbols)
4530       for (size_t i = 0; i < u.templates->get_nof_ts(); i++) {
4531         if (u.templates->get_t_byIndex(i)->templatetype != TEMPLATE_NOTUSED)
4532           return true;
4533       }
4534       return false;
4535     case INDEXED_TEMPLATE_LIST:
4536       for (size_t i = 0; i < u.indexed_templates->get_nof_its(); i++) {
4537         if (u.indexed_templates->get_it_byIndex(i)->get_template()
4538           ->templatetype != TEMPLATE_NOTUSED)
4539           return true;
4540       }
4541       return false;
4542     case NAMED_TEMPLATE_LIST:
4543       return u.named_templates->get_nof_nts() > 1;
4544     case ALL_FROM:
4545     case VALUE_LIST_ALL_FROM:
4546       return false;
4547     case VALUE_LIST:
4548     case COMPLEMENTED_LIST:
4549     case VALUE_RANGE:
4550     case SUPERSET_MATCH:
4551     case SUBSET_MATCH:
4552       return true;
4553     case TEMPLATE_ERROR:
4554     case TEMPLATE_NOTUSED:
4555       FATAL_ERROR("Template::needs_temp_ref()");
4556     case PERMUTATION_MATCH:
4557       // FIXME
4558       return false;
4559     }
4560     return false;
4561   }
4562
4563   bool Template::has_single_expr()
4564   {
4565     if (length_restriction || is_ifpresent || get_needs_conversion())
4566       return false;
4567     switch (templatetype) {
4568     case OMIT_VALUE:
4569     case ANY_VALUE:
4570     case ANY_OR_OMIT:
4571     case BSTR_PATTERN:
4572     case HSTR_PATTERN:
4573     case OSTR_PATTERN:
4574     case CSTR_PATTERN:
4575     case USTR_PATTERN:
4576       return true;
4577     case SPECIFIC_VALUE:
4578       return u.specific_value->has_single_expr();
4579     case TEMPLATE_REFD: {
4580       Template *t_last = get_template_refd_last();
4581       if (t_last != this && t_last->has_single_expr()) {
4582         for (Scope *t_scope = my_scope; t_scope;
4583              t_scope = t_scope->get_parent_scope()) {
4584           // return true if t_last is visible from my scope
4585           if (t_scope == t_last->my_scope) return true;
4586         }
4587       }
4588       // otherwise consider the reference itself
4589       return u.ref.ref->has_single_expr(); }
4590     case TEMPLATE_INVOKE:
4591       if (!u.invoke.v->has_single_expr()) return false;
4592       for (size_t i = 0; i < u.invoke.ap_list->get_nof_pars(); i++)
4593         if (!u.invoke.ap_list->get_par(i)->has_single_expr()) return false;
4594       return true;
4595     case TEMPLATE_LIST:
4596       return u.templates->get_nof_ts() == 0;
4597     case NAMED_TEMPLATE_LIST: {
4598       if (!my_governor) FATAL_ERROR("Template::has_single_expr()");
4599       Type *type = my_governor->get_type_refd_last();
4600       return type->get_nof_comps() == 0; }
4601     case INDEXED_TEMPLATE_LIST:
4602       return u.indexed_templates->get_nof_its() == 0;
4603     case VALUE_LIST:
4604     case COMPLEMENTED_LIST:
4605     case VALUE_RANGE:
4606     case SUPERSET_MATCH:
4607     case SUBSET_MATCH:
4608     case PERMUTATION_MATCH:
4609       return false;
4610     case ALL_FROM:
4611     case VALUE_LIST_ALL_FROM:
4612       return false;
4613     default:
4614       FATAL_ERROR("Template::has_single_expr()");
4615       return false;
4616     }
4617   }
4618
4619   string Template::get_single_expr(bool cast_needed)
4620   {
4621     if (cast_needed && (length_restriction || is_ifpresent))
4622       FATAL_ERROR("Template::get_single_expr()");
4623     string ret_val;
4624     switch (templatetype) {
4625     case OMIT_VALUE:
4626       ret_val = "OMIT_VALUE";
4627       break;
4628     case ANY_VALUE:
4629       ret_val = "ANY_VALUE";
4630       break;
4631     case ANY_OR_OMIT:
4632       ret_val = "ANY_OR_OMIT";
4633       break;
4634     case SPECIFIC_VALUE:
4635       ret_val = u.specific_value->get_single_expr();
4636       break;
4637     case TEMPLATE_REFD: {
4638       // convert the reference to a single expression
4639       expression_struct expr;
4640       Code::init_expr(&expr);
4641       u.ref.ref->generate_code(&expr);
4642       if (expr.preamble || expr.postamble)
4643         FATAL_ERROR("Template::get_single_expr()");
4644       ret_val = expr.expr;
4645       Code::free_expr(&expr);
4646       return ret_val;
4647       }
4648     case TEMPLATE_INVOKE: {
4649       expression_struct expr;
4650       Code::init_expr(&expr);
4651       generate_code_expr_invoke(&expr);
4652       if (expr.preamble || expr.postamble)
4653         FATAL_ERROR("Template::get_single_expr()");
4654       ret_val = expr.expr;
4655       Code::free_expr(&expr);
4656       return ret_val; }
4657     case TEMPLATE_LIST:
4658       if (u.templates->get_nof_ts() != 0)
4659         FATAL_ERROR("Template::get_single_expr()");
4660       ret_val = "NULL_VALUE";
4661       break;
4662     case NAMED_TEMPLATE_LIST:
4663       if (u.named_templates->get_nof_nts() != 0)
4664         FATAL_ERROR("Template::get_single_expr()");
4665       ret_val = "NULL_VALUE";
4666       break;
4667     case INDEXED_TEMPLATE_LIST:
4668       if (u.indexed_templates->get_nof_its() != 0)
4669         FATAL_ERROR("Template::get_single_expr()");
4670       ret_val = "NULL_VALUE";
4671       break;
4672     case BSTR_PATTERN:
4673       return get_my_scope()->get_scope_mod_gen()
4674         ->add_bitstring_pattern(*u.pattern);
4675     case HSTR_PATTERN:
4676       return get_my_scope()->get_scope_mod_gen()
4677         ->add_hexstring_pattern(*u.pattern);
4678     case OSTR_PATTERN:
4679       return get_my_scope()->get_scope_mod_gen()
4680         ->add_octetstring_pattern(*u.pattern);
4681     case CSTR_PATTERN:
4682     case USTR_PATTERN:
4683       return u.pstring
4684         ->create_charstring_literals(get_my_scope()->get_scope_mod_gen());
4685     default:
4686       FATAL_ERROR("Template::get_single_expr()");
4687     }
4688     if (cast_needed) ret_val = my_governor->get_genname_template(my_scope) +
4689       "(" + ret_val + ")";
4690     return ret_val;
4691   }
4692
4693   void Template::dump(unsigned level) const
4694   {
4695     DEBUG(level, "%s", get_templatetype_str());
4696     switch (templatetype) {
4697     case TEMPLATE_ERROR:
4698     case OMIT_VALUE:
4699     case ANY_VALUE:
4700     case ANY_OR_OMIT:
4701       break;
4702     case SPECIFIC_VALUE:
4703       u.specific_value->dump(level+1);
4704       break;
4705     case TEMPLATE_REFD:
4706       u.ref.ref->dump(level+1);
4707       break;
4708     case TEMPLATE_INVOKE:
4709       u.invoke.v->dump(level+1);
4710       if (u.invoke.ap_list) u.invoke.ap_list->dump(level + 1);
4711       else if (u.invoke.t_list) u.invoke.t_list->dump(level + 1);
4712       break;
4713     case TEMPLATE_LIST:
4714     case VALUE_LIST:
4715     case COMPLEMENTED_LIST:
4716     case SUPERSET_MATCH:
4717     case SUBSET_MATCH:
4718     case PERMUTATION_MATCH:
4719       for (size_t i = 0; i < u.templates->get_nof_ts(); i++)
4720         u.templates->get_t_byIndex(i)->dump(level+1);
4721       break;
4722     case NAMED_TEMPLATE_LIST:
4723       for (size_t i = 0; i < u.named_templates->get_nof_nts(); i++)
4724         u.named_templates->get_nt_byIndex(i)->dump(level+1);
4725       break;
4726     case INDEXED_TEMPLATE_LIST:
4727       for (size_t i = 0; i < u.indexed_templates->get_nof_its(); i++)
4728         u.indexed_templates->get_it_byIndex(i)->dump(level+1);
4729       break;
4730     case VALUE_RANGE:
4731       u.value_range->dump(level);
4732       break;
4733     case BSTR_PATTERN:
4734     case HSTR_PATTERN:
4735     case OSTR_PATTERN:
4736       DEBUG(level+1, "%s", u.pattern->c_str());
4737       break;
4738     case CSTR_PATTERN:
4739     case USTR_PATTERN:
4740       u.pstring->dump(level+1);
4741       break;
4742     case ALL_FROM:
4743     case VALUE_LIST_ALL_FROM:
4744       u.all_from->dump(level+1);
4745       break;
4746     default:
4747       break;
4748     }
4749     if (length_restriction) length_restriction->dump(level + 1);
4750   }
4751
4752   bool Template::has_allfrom() const
4753   { // the code generation of all from is not fully implemented. This helps avoid of using it.
4754     if (templatetype != TEMPLATE_LIST) FATAL_ERROR("has_allfrom(): Templatetype shall be TEMPLATE_LIST");
4755     size_t nof_ts = u.templates->get_nof_ts();
4756     for (size_t i = 0; i < nof_ts; i++) {
4757       if (u.templates->get_t_byIndex(i)->templatetype == ALL_FROM) {
4758         return true;
4759       }
4760     }
4761     return false;
4762   }
4763
4764   // =================================
4765   // ===== TemplateInstance
4766   // =================================
4767
4768   TemplateInstance::TemplateInstance(const TemplateInstance& p)
4769     : Node(p), Location(p)
4770   {
4771     type = p.type ? p.type->clone() : 0;
4772     derived_reference = p.derived_reference ? p.derived_reference->clone() : 0;
4773     template_body = p.template_body->clone();
4774   }
4775
4776   TemplateInstance::TemplateInstance(Type *p_type, Ref_base *p_ref,
4777     Template *p_body) : Node(), Location(), type(p_type),
4778     derived_reference(p_ref), template_body(p_body)
4779   {
4780     if (!p_body) FATAL_ERROR("TemplateInstance::TemplateInstance()");
4781     if (type) type->set_ownertype(Type::OT_TEMPLATE_INST, this);
4782   }
4783
4784    TemplateInstance::~TemplateInstance()
4785    {
4786      delete type;
4787      delete derived_reference;
4788      delete template_body;
4789    }
4790
4791    void TemplateInstance::release()
4792    {
4793      type = 0;
4794      derived_reference = 0;
4795      template_body = 0;
4796    }
4797
4798   TemplateInstance *TemplateInstance::clone() const
4799   {
4800     return new TemplateInstance(*this);
4801   }
4802
4803   void TemplateInstance::set_fullname(const string& p_fullname)
4804   {
4805     Node::set_fullname(p_fullname);
4806     if (type) type->set_fullname(p_fullname + ".<type>");
4807     if (derived_reference)
4808       derived_reference->set_fullname(p_fullname + ".<derived_reference>");
4809     template_body->set_fullname(p_fullname);
4810   }
4811
4812   void TemplateInstance::set_my_scope(Scope *p_scope)
4813   {
4814     if (type) type->set_my_scope(p_scope);
4815     if (derived_reference) derived_reference->set_my_scope(p_scope);
4816     template_body->set_my_scope(p_scope);
4817   }
4818
4819   Type::typetype_t TemplateInstance::get_expr_returntype
4820     (Type::expected_value_t exp_val)
4821   {
4822     Type *t = get_expr_governor(exp_val);
4823     if (t) return t->get_type_refd_last()->get_typetype_ttcn3();
4824     else return template_body->get_expr_returntype(exp_val);
4825   }
4826
4827   Type *TemplateInstance::get_expr_governor(Type::expected_value_t exp_val)
4828   {
4829     if (type) return type;
4830     if (derived_reference) {
4831       Type *ret_val = chk_DerivedRef(0);
4832       if (ret_val) return ret_val;
4833     }
4834     return template_body->get_expr_governor(exp_val);
4835   }
4836
4837   void TemplateInstance::chk(Type *governor)
4838   {
4839     if (!governor) FATAL_ERROR("TemplateInstance::chk()");
4840     governor = chk_Type(governor);
4841     governor = chk_DerivedRef(governor);
4842     template_body->set_my_governor(governor);
4843     governor->chk_this_template_ref(template_body);
4844     governor->chk_this_template_generic(template_body,
4845       (derived_reference != 0 ? INCOMPLETE_ALLOWED : INCOMPLETE_NOT_ALLOWED),
4846       OMIT_ALLOWED, ANY_OR_OMIT_ALLOWED, SUB_CHK, NOT_IMPLICIT_OMIT, 0);
4847   }
4848
4849   Type *TemplateInstance::chk_Type(Type *governor)
4850   {
4851     if (!type) return governor;
4852     {
4853       Error_Context cntxt(type, "In explicit type specification");
4854       type->chk();
4855     }
4856     TypeCompatInfo info(template_body->get_template_refd_last()
4857                         ->get_my_scope()->get_scope_mod(), governor, type,
4858                         true, false);
4859     TypeChain l_chain;
4860     TypeChain r_chain;
4861     if (!governor) return type;
4862     else if (governor->is_compatible(type, &info, &l_chain, &r_chain)) {
4863       return governor;
4864     } else {
4865       if (info.is_subtype_error()) {
4866         type->error("%s", info.get_subtype_error().c_str());
4867       } else
4868       if (!info.is_erroneous()) {
4869         type->error("Incompatible explicit type specification: `%s' was "
4870                     "expected instead of `%s'",
4871                     governor->get_typename().c_str(),
4872                     type->get_typename().c_str());
4873       } else {
4874         type->error("%s", info.get_error_str_str().c_str());
4875       }
4876       return type;
4877     }
4878   }
4879
4880   Type *TemplateInstance::chk_DerivedRef(Type *governor)
4881   {
4882     if (!derived_reference) return governor;
4883     Error_Context cntxt(derived_reference, "In derived reference");
4884     Common::Assignment *ass = derived_reference->get_refd_assignment();
4885     // the base template reference must not have sub-references
4886     if (derived_reference->get_subrefs())
4887       FATAL_ERROR("TemplateInstance::chk_DerivedRef()");
4888     bool set_bt = false;
4889     if (!ass) goto error;
4890     switch (ass->get_asstype()) {
4891     case Common::Assignment::A_TEMPLATE:
4892       set_bt = true;
4893       // no break
4894     case Common::Assignment::A_MODULEPAR_TEMP:
4895     case Common::Assignment::A_VAR_TEMPLATE:
4896     case Common::Assignment::A_PAR_TEMPL_IN:
4897     case Common::Assignment::A_PAR_TEMPL_OUT:
4898     case Common::Assignment::A_PAR_TEMPL_INOUT:
4899     case Common::Assignment::A_FUNCTION_RTEMP:
4900     case Common::Assignment::A_EXT_FUNCTION_RTEMP: {
4901       if (!governor) governor = type;
4902       Type *base_template_type = ass->get_Type();
4903       if (governor) {
4904         TypeCompatInfo info(template_body->get_template_refd_last()
4905                             ->get_my_scope()->get_scope_mod(), governor, type,
4906                             true, false);
4907         TypeChain l_chain;
4908         TypeChain r_chain;
4909         if (!governor->is_compatible(base_template_type, &info, &l_chain,
4910                                      &r_chain)) {
4911           if (info.is_subtype_error()) {
4912             derived_reference->error("%s", info.get_subtype_error().c_str());
4913           } else
4914           if (!info.is_erroneous()) {
4915             derived_reference->error("Base template `%s' has incompatible "
4916                                      "type: `%s' was expected instead of `%s'",
4917                                      ass->get_fullname().c_str(),
4918                                      governor->get_typename().c_str(),
4919                                      base_template_type->get_typename().c_str());
4920           } else {
4921             derived_reference->error("%s", info.get_error_str_str().c_str());
4922           }
4923           // if explicit type specification is omitted
4924           // check the template body against the type of the base template
4925           if (!type) governor = base_template_type;
4926           set_bt = false;
4927         } else {
4928           if (info.needs_conversion())
4929             template_body->set_needs_conversion();
4930         }
4931       } else governor = base_template_type;
4932       break; }
4933     default:
4934       derived_reference->error("Reference to a template was expected instead "
4935                                "of %s", ass->get_description().c_str());
4936       goto error;
4937     }
4938     if (set_bt) template_body->set_base_template(ass->get_Template());
4939     return governor;
4940   error:
4941     // drop the erroneous derived_reference to avoid further errors
4942     delete derived_reference;
4943     derived_reference = 0;
4944     return governor;
4945   }
4946
4947   void TemplateInstance::chk_recursions(ReferenceChain& refch)
4948   {
4949     template_body->chk_recursions(refch);
4950   }
4951
4952   bool TemplateInstance::is_string_type(Type::expected_value_t exp_val)
4953   {
4954     switch (get_expr_returntype(exp_val)) {
4955     case Type::T_CSTR:
4956     case Type::T_USTR:
4957     case Type::T_BSTR:
4958     case Type::T_HSTR:
4959     case Type::T_OSTR:
4960       return true;
4961     default:
4962       return false;
4963     }
4964   }
4965
4966   bool TemplateInstance::chk_restriction(const char* definition_name,
4967     template_restriction_t template_restriction, const Location* usage_loc)
4968   {
4969     bool needs_runtime_check = false;
4970     if (derived_reference) // if modified
4971     {
4972       Common::Assignment *ass = derived_reference->get_refd_assignment();
4973       switch (ass->get_asstype()) {
4974       case Common::Assignment::A_TEMPLATE:
4975         // already added to template_body as base template by chk_DerivedRef()
4976         needs_runtime_check = template_body->chk_restriction(
4977           definition_name, template_restriction, usage_loc);
4978         break;
4979       case Common::Assignment::A_MODULEPAR_TEMP:
4980       case Common::Assignment::A_VAR_TEMPLATE:
4981       case Common::Assignment::A_EXT_FUNCTION_RTEMP:
4982       case Common::Assignment::A_FUNCTION_RTEMP:
4983       case Common::Assignment::A_PAR_TEMPL_IN:
4984       case Common::Assignment::A_PAR_TEMPL_OUT:
4985       case Common::Assignment::A_PAR_TEMPL_INOUT: {
4986         // create a temporary Template to be added as the base template and
4987         // check, remove and delete after checked
4988         if (template_body->get_base_template())
4989           FATAL_ERROR("TemplateInstance::chk_restriction()");
4990         template_body->set_base_template(new Template(derived_reference));
4991         needs_runtime_check = template_body->chk_restriction(
4992           definition_name, template_restriction, usage_loc);
4993         delete template_body->get_base_template();
4994         template_body->set_base_template(0);
4995       } break;
4996       default:
4997         break;
4998       }
4999     } else { // simple
5000       needs_runtime_check = template_body->chk_restriction(definition_name,
5001                               template_restriction, usage_loc);
5002     }
5003     return needs_runtime_check;
5004   }
5005
5006   bool TemplateInstance::has_single_expr()
5007   {
5008     if (derived_reference) return false;
5009     else if (type) return false;
5010     else return template_body->has_single_expr();
5011   }
5012
5013   void TemplateInstance::set_code_section(
5014     GovernedSimple::code_section_t p_code_section)
5015   {
5016     if (derived_reference) derived_reference->set_code_section(p_code_section);
5017     template_body->set_code_section(p_code_section);
5018   }
5019
5020   bool TemplateInstance::needs_temp_ref()
5021   {
5022     if (template_body->get_templatetype() != Template::SPECIFIC_VALUE)
5023       return false;
5024     Value *val = template_body->get_specific_value();
5025     if (val->get_valuetype() == Value::V_REFD) {
5026       FieldOrArrayRefs *refs = val->get_reference()->get_subrefs();
5027       if (!refs) return false;
5028       // We need at least a 2-long reference chain.  E.g. "a[0].b".  3.0.4
5029       // can't handle a normal reference following an indexed reference.  The
5030       // indexed reference must be on the first place.  Code like: "a.b[0].c"
5031       // compiles fine.
5032       if (refs->get_nof_refs() < 2
5033           || refs->get_ref(0)->get_type() != FieldOrArrayRef::ARRAY_REF)
5034         return false;
5035     } else {
5036       return false;
5037     }
5038     return true;
5039   }
5040
5041   void TemplateInstance::generate_code(expression_struct *expr,
5042     template_restriction_t template_restriction)
5043   {
5044     if (derived_reference) {
5045       // preserve the target expression
5046       char *expr_backup = expr->expr;
5047       // reset the space for the target expression
5048       expr->expr = NULL;
5049       derived_reference->generate_code(expr);
5050       // now the C++ equivalent of the base template reference is in expr->expr
5051       const string& tmp_id = template_body->get_temporary_id();
5052       const char *tmp_id_str = tmp_id.c_str();
5053       // create a temporary variable and copy the contents of base template
5054       // into it
5055       expr->preamble = mputprintf(expr->preamble, "%s %s(%s);\n",
5056         template_body->get_my_governor()->get_genname_template(
5057         template_body->get_my_scope()).c_str(), tmp_id_str, expr->expr);
5058       // perform the modifications on the temporary variable
5059       expr->preamble = template_body->generate_code_init(expr->preamble,
5060         tmp_id_str);
5061       // runtime template restriction check
5062       if (template_restriction!=TR_NONE)
5063         expr->preamble = Template::generate_restriction_check_code(
5064           expr->preamble, tmp_id_str, template_restriction);
5065       // the base template reference is no longer needed
5066       Free(expr->expr);
5067       // restore the target expression append the name of the temporary
5068       // variable to it
5069       expr->expr = mputstr(expr_backup, tmp_id_str);
5070     } else template_body->generate_code_expr(expr, template_restriction);
5071   }
5072
5073   char *TemplateInstance::rearrange_init_code(char *str)
5074   {
5075     if (derived_reference) {
5076       ActualParList *parlist = derived_reference->get_parlist();
5077       Common::Assignment *ass = derived_reference->get_refd_assignment();
5078       if (!ass) FATAL_ERROR("TemplateInstance::rearrange_init_code()");
5079       bool is_local = (ass->get_my_scope()->get_scope_mod_gen() ==
5080         derived_reference->get_my_scope()->get_scope_mod_gen());
5081       if (parlist) str = parlist->rearrange_init_code(str, is_local);
5082       if (is_local && ass->get_asstype() == Common::Assignment::A_TEMPLATE) {
5083         // the base template reference refers to a template within the local
5084         // module
5085         Template *t = ass->get_Template();
5086         if (parlist) {
5087           // the referred template is parameterized
5088           // the embedded referenced templates shall be visited
5089           str = t->rearrange_init_code(str);
5090         } else {
5091           // the referred template is not parameterized
5092           // its entire body has to be initialized now
5093           str = t->generate_code_init(str, t->get_lhs_name().c_str());
5094         }
5095       }
5096     }
5097     str = template_body->rearrange_init_code(str);
5098     return str;
5099   }
5100
5101   void TemplateInstance::append_stringRepr(string& str) const
5102   {
5103     if (type) {
5104       str += type->get_typename();
5105       str += " : ";
5106     }
5107     if (derived_reference) {
5108       str += "modifies ";
5109       str += derived_reference->get_dispname();
5110       str += " := ";
5111     }
5112     str += template_body->get_stringRepr();
5113   }
5114
5115   void TemplateInstance::dump(unsigned level) const
5116   {
5117     if (type) {
5118       DEBUG(level, "type:");
5119       type->dump(level + 1);
5120     }
5121     if (derived_reference) {
5122       DEBUG(level, "modifies:");
5123       derived_reference->dump(level + 1);
5124     }
5125     template_body->dump(level);
5126   }
5127
5128   Value* TemplateInstance::get_specific_value() const
5129   {
5130     if (type) return NULL;
5131     if (derived_reference) return NULL;
5132     if (template_body->is_length_restricted() || template_body->get_ifpresent())
5133       return NULL;
5134     if (template_body->get_templatetype()!=Template::SPECIFIC_VALUE) return NULL;
5135     return template_body->get_specific_value();
5136   }
5137
5138   Def_Template* TemplateInstance::get_Referenced_Base_Template()
5139   { // it may return 0
5140     if (!get_Template()) return NULL;
5141     Ttcn::Template::templatetype_t tpt =  get_Template()->get_templatetype();
5142     if (Ttcn::Template::TEMPLATE_REFD != tpt) return NULL;
5143     Ttcn::Ref_base* refbase = get_Template()->get_reference();
5144     Ttcn::Reference * ref = dynamic_cast<Ttcn::Reference*>(refbase);
5145     if (!ref) return NULL;
5146     Common::Assignment* ass = ref->get_refd_assignment();
5147     Ttcn::Definition* def = dynamic_cast<Ttcn::Definition*>(ass);
5148     if (!def) return NULL;
5149     Ttcn::Def_Template* deftemp = dynamic_cast<Ttcn::Def_Template*>(def);
5150     if (!deftemp) return NULL;
5151
5152     return deftemp;
5153   }
5154
5155 }
5156