prop-src/constr.cc

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //  This file is generated automatically using Prop (version 2.3.6),
   3 //  last updated on Nov 2, 1999.
   4 //  The original source file is "constr.pcc".
   5 ///////////////////////////////////////////////////////////////////////////////
   6
   7 #line 1 "constr.pcc"
   8 ///////////////////////////////////////////////////////////////////////////////
   9 //
  10 //  This file simply instantiates all the datatypes used in the Prop -> C++
  11 //  translator.
  12 //
  13 ///////////////////////////////////////////////////////////////////////////////
  14 #include "ir.h"
  15 #include "ast.h"
  16 #include "matchcom.h"
  17
  18 #line 11 "constr.pcc"
  19 #line 11 "constr.pcc"
  20 ///////////////////////////////////////////////////////////////////////////////
  21 //
  22 // Interface specification of datatype Ty
  23 //
  24 ///////////////////////////////////////////////////////////////////////////////
  25 #line 11 "constr.pcc"
  26
  27
  28 ///////////////////////////////////////////////////////////////////////////////
  29 //
  30 // Interface specification of datatype TyCon
  31 //
  32 ///////////////////////////////////////////////////////////////////////////////
  33 #line 11 "constr.pcc"
  34
  35
  36 ///////////////////////////////////////////////////////////////////////////////
  37 //
  38 // Interface specification of datatype Pat
  39 //
  40 ///////////////////////////////////////////////////////////////////////////////
  41 #line 11 "constr.pcc"
  42
  43
  44 ///////////////////////////////////////////////////////////////////////////////
  45 //
  46 // Interface specification of datatype Exp
  47 //
  48 ///////////////////////////////////////////////////////////////////////////////
  49 #line 11 "constr.pcc"
  50
  51
  52 ///////////////////////////////////////////////////////////////////////////////
  53 //
  54 // Interface specification of datatype Cons
  55 //
  56 ///////////////////////////////////////////////////////////////////////////////
  57 #line 11 "constr.pcc"
  58
  59
  60 ///////////////////////////////////////////////////////////////////////////////
  61 //
  62 // Interface specification of datatype Pos
  63 //
  64 ///////////////////////////////////////////////////////////////////////////////
  65 #line 11 "constr.pcc"
  66
  67
  68 ///////////////////////////////////////////////////////////////////////////////
  69 //
  70 // Interface specification of datatype Match
  71 //
  72 ///////////////////////////////////////////////////////////////////////////////
  73 #line 11 "constr.pcc"
  74
  75
  76 ///////////////////////////////////////////////////////////////////////////////
  77 //
  78 // Interface specification of datatype Decl
  79 //
  80 ///////////////////////////////////////////////////////////////////////////////
  81 #line 11 "constr.pcc"
  82
  83
  84 ///////////////////////////////////////////////////////////////////////////////
  85 //
  86 // Interface specification of datatype MatchExp
  87 //
  88 ///////////////////////////////////////////////////////////////////////////////
  89 #line 11 "constr.pcc"
  90
  91
  92 ///////////////////////////////////////////////////////////////////////////////
  93 //
  94 // Interface specification of datatype Inherit
  95 //
  96 ///////////////////////////////////////////////////////////////////////////////
  97 #line 11 "constr.pcc"
  98
  99
 100 ///////////////////////////////////////////////////////////////////////////////
 101 //
 102 // Interface specification of datatype Literal
 103 //
 104 ///////////////////////////////////////////////////////////////////////////////
 105 #line 11 "constr.pcc"
 106
 107
 108 ///////////////////////////////////////////////////////////////////////////////
 109 //
 110 // Interface specification of datatype Cost
 111 //
 112 ///////////////////////////////////////////////////////////////////////////////
 113 #line 11 "constr.pcc"
 114
 115
 116 ///////////////////////////////////////////////////////////////////////////////
 117 //
 118 // Interface specification of datatype MatchRule
 119 //
 120 ///////////////////////////////////////////////////////////////////////////////
 121 #line 11 "constr.pcc"
 122
 123
 124 ///////////////////////////////////////////////////////////////////////////////
 125 //
 126 // Interface specification of datatype Protocol
 127 //
 128 ///////////////////////////////////////////////////////////////////////////////
 129 #line 11 "constr.pcc"
 130
 131
 132 ///////////////////////////////////////////////////////////////////////////////
 133 //
 134 // Interface specification of datatype DatatypeDef
 135 //
 136 ///////////////////////////////////////////////////////////////////////////////
 137 #line 11 "constr.pcc"
 138
 139
 140 ///////////////////////////////////////////////////////////////////////////////
 141 //
 142 // Interface specification of datatype TyDef
 143 //
 144 ///////////////////////////////////////////////////////////////////////////////
 145 #line 11 "constr.pcc"
 146
 147
 148 ///////////////////////////////////////////////////////////////////////////////
 149 //
 150 // Interface specification of datatype TermDef
 151 //
 152 ///////////////////////////////////////////////////////////////////////////////
 153 #line 11 "constr.pcc"
 154
 155
 156 ///////////////////////////////////////////////////////////////////////////////
 157 //
 158 // Interface specification of datatype ViewDef
 159 //
 160 ///////////////////////////////////////////////////////////////////////////////
 161 #line 11 "constr.pcc"
 162
 163
 164 ///////////////////////////////////////////////////////////////////////////////
 165 //
 166 // Interface specification of datatype LawDef
 167 //
 168 ///////////////////////////////////////////////////////////////////////////////
 169 #line 11 "constr.pcc"
 170
 171
 172 ///////////////////////////////////////////////////////////////////////////////
 173 //
 174 // Interface specification of datatype FunDef
 175 //
 176 ///////////////////////////////////////////////////////////////////////////////
 177 #line 11 "constr.pcc"
 178
 179
 180 ///////////////////////////////////////////////////////////////////////////////
 181 //
 182 // Interface specification of datatype QualId
 183 //
 184 ///////////////////////////////////////////////////////////////////////////////
 185 #line 11 "constr.pcc"
 186
 187
 188 ///////////////////////////////////////////////////////////////////////////////
 189 //
 190 // Interface specification of datatype InferenceRule
 191 //
 192 ///////////////////////////////////////////////////////////////////////////////
 193 #line 11 "constr.pcc"
 194
 195
 196 ///////////////////////////////////////////////////////////////////////////////
 197 //
 198 // Interface specification of datatype Conclusion
 199 //
 200 ///////////////////////////////////////////////////////////////////////////////
 201 #line 11 "constr.pcc"
 202
 203
 204 ///////////////////////////////////////////////////////////////////////////////
 205 //
 206 // Interface specification of datatype LogicalPat
 207 //
 208 ///////////////////////////////////////////////////////////////////////////////
 209 #line 11 "constr.pcc"
 210
 211
 212 ///////////////////////////////////////////////////////////////////////////////
 213 //
 214 // Interface specification of datatype Scope
 215 //
 216 ///////////////////////////////////////////////////////////////////////////////
 217 #line 11 "constr.pcc"
 218
 219
 220 ///////////////////////////////////////////////////////////////////////////////
 221 //
 222 // Interface specification of datatype Polarity
 223 //
 224 ///////////////////////////////////////////////////////////////////////////////
 225 #line 11 "constr.pcc"
 226
 227
 228 ///////////////////////////////////////////////////////////////////////////////
 229 //
 230 // Interface specification of datatype List<Ty>
 231 //
 232 ///////////////////////////////////////////////////////////////////////////////
 233 #line 11 "constr.pcc"
 234
 235
 236 ///////////////////////////////////////////////////////////////////////////////
 237 //
 238 // Interface specification of datatype List<Pat>
 239 //
 240 ///////////////////////////////////////////////////////////////////////////////
 241 #line 11 "constr.pcc"
 242
 243
 244 ///////////////////////////////////////////////////////////////////////////////
 245 //
 246 // Interface specification of datatype List<Exp>
 247 //
 248 ///////////////////////////////////////////////////////////////////////////////
 249 #line 11 "constr.pcc"
 250
 251
 252 ///////////////////////////////////////////////////////////////////////////////
 253 //
 254 // Interface specification of datatype List<Pos>
 255 //
 256 ///////////////////////////////////////////////////////////////////////////////
 257 #line 11 "constr.pcc"
 258
 259
 260 ///////////////////////////////////////////////////////////////////////////////
 261 //
 262 // Interface specification of datatype List<Decl>
 263 //
 264 ///////////////////////////////////////////////////////////////////////////////
 265 #line 11 "constr.pcc"
 266
 267
 268 ///////////////////////////////////////////////////////////////////////////////
 269 //
 270 // Interface specification of datatype List<Inherit>
 271 //
 272 ///////////////////////////////////////////////////////////////////////////////
 273 #line 11 "constr.pcc"
 274
 275
 276 ///////////////////////////////////////////////////////////////////////////////
 277 //
 278 // Interface specification of datatype List<MatchExp>
 279 //
 280 ///////////////////////////////////////////////////////////////////////////////
 281 #line 11 "constr.pcc"
 282
 283
 284 ///////////////////////////////////////////////////////////////////////////////
 285 //
 286 // Interface specification of datatype List<MatchRule>
 287 //
 288 ///////////////////////////////////////////////////////////////////////////////
 289 #line 11 "constr.pcc"
 290
 291
 292 ///////////////////////////////////////////////////////////////////////////////
 293 //
 294 // Interface specification of datatype List<Protocol>
 295 //
 296 ///////////////////////////////////////////////////////////////////////////////
 297 #line 11 "constr.pcc"
 298
 299
 300 ///////////////////////////////////////////////////////////////////////////////
 301 //
 302 // Interface specification of datatype List<DatatypeDef>
 303 //
 304 ///////////////////////////////////////////////////////////////////////////////
 305 #line 11 "constr.pcc"
 306
 307
 308 ///////////////////////////////////////////////////////////////////////////////
 309 //
 310 // Interface specification of datatype List<TyDef>
 311 //
 312 ///////////////////////////////////////////////////////////////////////////////
 313 #line 11 "constr.pcc"
 314
 315
 316 ///////////////////////////////////////////////////////////////////////////////
 317 //
 318 // Interface specification of datatype List<TermDef>
 319 //
 320 ///////////////////////////////////////////////////////////////////////////////
 321 #line 11 "constr.pcc"
 322
 323
 324 ///////////////////////////////////////////////////////////////////////////////
 325 //
 326 // Interface specification of datatype List<ViewDef>
 327 //
 328 ///////////////////////////////////////////////////////////////////////////////
 329 #line 11 "constr.pcc"
 330
 331
 332 ///////////////////////////////////////////////////////////////////////////////
 333 //
 334 // Interface specification of datatype List<LawDef>
 335 //
 336 ///////////////////////////////////////////////////////////////////////////////
 337 #line 11 "constr.pcc"
 338
 339
 340 ///////////////////////////////////////////////////////////////////////////////
 341 //
 342 // Interface specification of datatype List<FunDef>
 343 //
 344 ///////////////////////////////////////////////////////////////////////////////
 345 #line 11 "constr.pcc"
 346
 347
 348 ///////////////////////////////////////////////////////////////////////////////
 349 //
 350 // Interface specification of datatype List<QualId>
 351 //
 352 ///////////////////////////////////////////////////////////////////////////////
 353 #line 11 "constr.pcc"
 354
 355
 356 ///////////////////////////////////////////////////////////////////////////////
 357 //
 358 // Interface specification of datatype List<InferenceRule>
 359 //
 360 ///////////////////////////////////////////////////////////////////////////////
 361 #line 11 "constr.pcc"
 362
 363
 364 ///////////////////////////////////////////////////////////////////////////////
 365 //
 366 // Interface specification of datatype List<Conclusion>
 367 //
 368 ///////////////////////////////////////////////////////////////////////////////
 369 #line 11 "constr.pcc"
 370
 371
 372 ///////////////////////////////////////////////////////////////////////////////
 373 //
 374 // Interface specification of datatype List<Scope>
 375 //
 376 ///////////////////////////////////////////////////////////////////////////////
 377 #line 11 "constr.pcc"
 378
 379
 380 ///////////////////////////////////////////////////////////////////////////////
 381 //
 382 // Interface specification of datatype Pid
 383 //
 384 ///////////////////////////////////////////////////////////////////////////////
 385 #line 11 "constr.pcc"
 386
 387
 388 ///////////////////////////////////////////////////////////////////////////////
 389 //
 390 // Interface specification of datatype Pair<Id, Tys>
 391 //
 392 ///////////////////////////////////////////////////////////////////////////////
 393 #line 11 "constr.pcc"
 394
 395
 396 ///////////////////////////////////////////////////////////////////////////////
 397 //
 398 // Interface specification of datatype Generator
 399 //
 400 ///////////////////////////////////////////////////////////////////////////////
 401 #line 11 "constr.pcc"
 402
 403
 404 ///////////////////////////////////////////////////////////////////////////////
 405 //
 406 // Interface specification of datatype List<Generator>
 407 //
 408 ///////////////////////////////////////////////////////////////////////////////
 409 #line 11 "constr.pcc"
 410
 411
 412 ///////////////////////////////////////////////////////////////////////////////
 413 //
 414 // Interface specification of datatype List<RewriteIndexing *>
 415 //
 416 ///////////////////////////////////////////////////////////////////////////////
 417 #line 11 "constr.pcc"
 418
 419
 420 ///////////////////////////////////////////////////////////////////////////////
 421 //
 422 // Instantiation of datatype Ty
 423 //
 424 ///////////////////////////////////////////////////////////////////////////////
 425 #line 11 "constr.pcc"
 426 Ty_VARty::Ty_VARty (Ty x_VARty)
 427  : a_Ty(tag_VARty), VARty(x_VARty)
 428 {
 429 }
 430 a_Ty * VARty (Ty x_VARty)
 431 {
 432    return new Ty_VARty (x_VARty);
 433 }
 434 Ty_INDty::Ty_INDty (Id x_1, int x_2)
 435  : a_Ty(tag_INDty), _1(x_1), _2(x_2)
 436 {
 437 }
 438 a_Ty * INDty (Id x_1, int x_2)
 439 {
 440    return new Ty_INDty (x_1, x_2);
 441 }
 442 Ty_QUALty::Ty_QUALty (TyQual x_1, Ty x_2)
 443  : a_Ty(tag_QUALty), _1(x_1), _2(x_2)
 444 {
 445 }
 446 a_Ty * QUALty (TyQual x_1, Ty x_2)
 447 {
 448    return new Ty_QUALty (x_1, x_2);
 449 }
 450 Ty_TYCONty::Ty_TYCONty (TyCon x_1, a_List<Ty> *  x_2)
 451  : a_Ty(tag_TYCONty), _1(x_1), _2(x_2)
 452 {
 453 }
 454 a_Ty * TYCONty (TyCon x_1, a_List<Ty> *  x_2)
 455 {
 456    return new Ty_TYCONty (x_1, x_2);
 457 }
 458 Ty_POLYty::Ty_POLYty (Ty x_1, int x_2, TyVar * x_3)
 459  : a_Ty(tag_POLYty), _1(x_1), _2(x_2), _3(x_3)
 460 {
 461 }
 462 a_Ty * POLYty (Ty x_1, int x_2, TyVar * x_3)
 463 {
 464    return new Ty_POLYty (x_1, x_2, x_3);
 465 }
 466 Ty_DEFVALty::Ty_DEFVALty (Ty x_1, Exp x_2)
 467  : a_Ty(tag_DEFVALty), _1(x_1), _2(x_2)
 468 {
 469 }
 470 a_Ty * DEFVALty (Ty x_1, Exp x_2)
 471 {
 472    return new Ty_DEFVALty (x_1, x_2);
 473 }
 474 Ty_NESTEDty::Ty_NESTEDty (Ty x_1, Ty x_2)
 475  : a_Ty(tag_NESTEDty), _1(x_1), _2(x_2)
 476 {
 477 }
 478 a_Ty * NESTEDty (Ty x_1, Ty x_2)
 479 {
 480    return new Ty_NESTEDty (x_1, x_2);
 481 }
 482
 483
 484 ///////////////////////////////////////////////////////////////////////////////
 485 //
 486 // Instantiation of datatype TyCon
 487 //
 488 ///////////////////////////////////////////////////////////////////////////////
 489 #line 11 "constr.pcc"
 490 TyCon_IDtycon::TyCon_IDtycon (Id x_IDtycon)
 491  : a_TyCon(tag_IDtycon), IDtycon(x_IDtycon)
 492 {
 493 }
 494 a_TyCon * IDtycon (Id x_IDtycon)
 495 {
 496    return new TyCon_IDtycon (x_IDtycon);
 497 }
 498 TyCon_RECORDtycon::TyCon_RECORDtycon (a_List<Id> *  x_1, Bool x_2)
 499  : a_TyCon(tag_RECORDtycon), _1(x_1), _2(x_2)
 500 {
 501 }
 502 a_TyCon * RECORDtycon (a_List<Id> *  x_1, Bool x_2)
 503 {
 504    return new TyCon_RECORDtycon (x_1, x_2);
 505 }
 506 TyCon_ARRAYtycon::TyCon_ARRAYtycon (Exp x_ARRAYtycon)
 507  : a_TyCon(tag_ARRAYtycon), ARRAYtycon(x_ARRAYtycon)
 508 {
 509 }
 510 a_TyCon * ARRAYtycon (Exp x_ARRAYtycon)
 511 {
 512    return new TyCon_ARRAYtycon (x_ARRAYtycon);
 513 }
 514 TyCon_BITFIELDtycon::TyCon_BITFIELDtycon (int x_width, Bool x_is_signed)
 515  : a_TyCon(tag_BITFIELDtycon), width(x_width), is_signed(x_is_signed)
 516 {
 517 }
 518 a_TyCon * BITFIELDtycon (int x_width, Bool x_is_signed)
 519 {
 520    return new TyCon_BITFIELDtycon (x_width, x_is_signed);
 521 }
 522 TyCon_DATATYPEtycon::TyCon_DATATYPEtycon (Id x_id, int x_unit, int x_arg, Cons * x_terms, TyVars x_tyvars, Ty x_polyty, a_List<Inherit> *  x_inherit, TyQual x_qualifiers, TyOpt x_opt, a_List<Decl> *  x_body, Exp x_view_match, Loc const * x_location, DatatypeHierarchy * x_hierarchy)
 523  : a_TyCon(tag_DATATYPEtycon), id(x_id), unit(x_unit), arg(x_arg), terms(x_terms), tyvars(x_tyvars), polyty(x_polyty), inherit(x_inherit), qualifiers(x_qualifiers), opt(x_opt), body(x_body), view_match(x_view_match), location(x_location), hierarchy(x_hierarchy)
 524 {
 525 }
 526 a_TyCon * DATATYPEtycon (Id x_id, int x_unit, int x_arg, Cons * x_terms, TyVars x_tyvars, Ty x_polyty, a_List<Inherit> *  x_inherit, TyQual x_qualifiers, TyOpt x_opt, a_List<Decl> *  x_body, Exp x_view_match, Loc const * x_location, DatatypeHierarchy * x_hierarchy)
 527 {
 528    return new TyCon_DATATYPEtycon (x_id, x_unit, x_arg, x_terms, x_tyvars, x_polyty, x_inherit, x_qualifiers, x_opt, x_body, x_view_match, x_location, x_hierarchy);
 529 }
 530 TyCon_COLtycon::TyCon_COLtycon (CollectionDesc x_COLtycon)
 531  : a_TyCon(tag_COLtycon), COLtycon(x_COLtycon)
 532 {
 533 }
 534 a_TyCon * COLtycon (CollectionDesc x_COLtycon)
 535 {
 536    return new TyCon_COLtycon (x_COLtycon);
 537 }
 538 TyCon_GRAPHtycon::TyCon_GRAPHtycon (GraphTypeDef * x_GRAPHtycon)
 539  : a_TyCon(tag_GRAPHtycon), GRAPHtycon(x_GRAPHtycon)
 540 {
 541 }
 542 a_TyCon * GRAPHtycon (GraphTypeDef * x_GRAPHtycon)
 543 {
 544    return new TyCon_GRAPHtycon (x_GRAPHtycon);
 545 }
 546 TyCon_NODEtycon::TyCon_NODEtycon (NodeDef * x_NODEtycon)
 547  : a_TyCon(tag_NODEtycon), NODEtycon(x_NODEtycon)
 548 {
 549 }
 550 a_TyCon * NODEtycon (NodeDef * x_NODEtycon)
 551 {
 552    return new TyCon_NODEtycon (x_NODEtycon);
 553 }
 554 TyCon_EDGEtycon::TyCon_EDGEtycon (EdgeDef * x_EDGEtycon)
 555  : a_TyCon(tag_EDGEtycon), EDGEtycon(x_EDGEtycon)
 556 {
 557 }
 558 a_TyCon * EDGEtycon (EdgeDef * x_EDGEtycon)
 559 {
 560    return new TyCon_EDGEtycon (x_EDGEtycon);
 561 }
 562
 563
 564 ///////////////////////////////////////////////////////////////////////////////
 565 //
 566 // Instantiation of datatype Pat
 567 //
 568 ///////////////////////////////////////////////////////////////////////////////
 569 #line 11 "constr.pcc"
 570 Pat_WILDpat::Pat_WILDpat ()
 571  : a_Pat(tag_WILDpat)
 572 {
 573 }
 574 a_Pat * WILDpat ()
 575 {
 576    return new Pat_WILDpat ;
 577 }
 578 Pat_INDpat::Pat_INDpat (Id x_1, int x_2, Ty x_3)
 579  : a_Pat(tag_INDpat), _1(x_1), _2(x_2), _3(x_3)
 580 {
 581 }
 582 a_Pat * INDpat (Id x_1, int x_2, Ty x_3)
 583 {
 584    return new Pat_INDpat (x_1, x_2, x_3);
 585 }
 586 Pat_POLYpat::Pat_POLYpat (Id x_1, int x_2, Ids x_3, Pat x_4, Exp x_5, Bool x_6)
 587  : a_Pat(tag_POLYpat), _1(x_1), _2(x_2), _3(x_3), _4(x_4), _5(x_5), _6(x_6)
 588 {
 589 }
 590 a_Pat * POLYpat (Id x_1, int x_2, Ids x_3, Pat x_4, Exp x_5, Bool x_6)
 591 {
 592    return new Pat_POLYpat (x_1, x_2, x_3, x_4, x_5, x_6);
 593 }
 594 Pat_IDpat::Pat_IDpat (Id x_1, Ty x_2, Exp x_3)
 595  : a_Pat(tag_IDpat), _1(x_1), _2(x_2), _3(x_3)
 596 {
 597 }
 598 a_Pat * IDpat (Id x_1, Ty x_2, Exp x_3)
 599 {
 600    return new Pat_IDpat (x_1, x_2, x_3);
 601 }
 602 Pat_CONSpat::Pat_CONSpat (Cons x_CONSpat)
 603  : a_Pat(tag_CONSpat), CONSpat(x_CONSpat)
 604 {
 605 }
 606 a_Pat * CONSpat (Cons x_CONSpat)
 607 {
 608    return new Pat_CONSpat (x_CONSpat);
 609 }
 610 Pat_APPpat::Pat_APPpat (Pat x_1, Pat x_2)
 611  : a_Pat(tag_APPpat), _1(x_1), _2(x_2)
 612 {
 613 }
 614 a_Pat * APPpat (Pat x_1, Pat x_2)
 615 {
 616    return new Pat_APPpat (x_1, x_2);
 617 }
 618 Pat_TYPEDpat::Pat_TYPEDpat (Pat x_1, Ty x_2)
 619  : a_Pat(tag_TYPEDpat), _1(x_1), _2(x_2)
 620 {
 621 }
 622 a_Pat * TYPEDpat (Pat x_1, Ty x_2)
 623 {
 624    return new Pat_TYPEDpat (x_1, x_2);
 625 }
 626 Pat_ASpat::Pat_ASpat (Id x_1, Pat x_2, Ty x_3, Exp x_4)
 627  : a_Pat(tag_ASpat), _1(x_1), _2(x_2), _3(x_3), _4(x_4)
 628 {
 629 }
 630 a_Pat * ASpat (Id x_1, Pat x_2, Ty x_3, Exp x_4)
 631 {
 632    return new Pat_ASpat (x_1, x_2, x_3, x_4);
 633 }
 634 Pat_LITERALpat::Pat_LITERALpat (Literal x_LITERALpat)
 635  : a_Pat(tag_LITERALpat), LITERALpat(x_LITERALpat)
 636 {
 637 }
 638 a_Pat * LITERALpat (Literal x_LITERALpat)
 639 {
 640    return new Pat_LITERALpat (x_LITERALpat);
 641 }
 642 Pat_CONTEXTpat::Pat_CONTEXTpat (Conses x_1, Pat x_2)
 643  : a_Pat(tag_CONTEXTpat), _1(x_1), _2(x_2)
 644 {
 645 }
 646 a_Pat * CONTEXTpat (Conses x_1, Pat x_2)
 647 {
 648    return new Pat_CONTEXTpat (x_1, x_2);
 649 }
 650 Pat_LEXEMEpat::Pat_LEXEMEpat (Id x_1, Ty x_2, int x_3, Cons * x_4)
 651  : a_Pat(tag_LEXEMEpat), _1(x_1), _2(x_2), _3(x_3), _4(x_4)
 652 {
 653 }
 654 a_Pat * LEXEMEpat (Id x_1, Ty x_2, int x_3, Cons * x_4)
 655 {
 656    return new Pat_LEXEMEpat (x_1, x_2, x_3, x_4);
 657 }
 658 Pat_ARRAYpat::Pat_ARRAYpat (a_List<Pat> *  x_1, Bool x_2)
 659  : a_Pat(tag_ARRAYpat), _1(x_1), _2(x_2)
 660 {
 661 }
 662 a_Pat * ARRAYpat (a_List<Pat> *  x_1, Bool x_2)
 663 {
 664    return new Pat_ARRAYpat (x_1, x_2);
 665 }
 666 Pat_TUPLEpat::Pat_TUPLEpat (a_List<Pat> *  x_TUPLEpat)
 667  : a_Pat(tag_TUPLEpat), TUPLEpat(x_TUPLEpat)
 668 {
 669 }
 670 a_Pat * TUPLEpat (a_List<Pat> *  x_TUPLEpat)
 671 {
 672    return new Pat_TUPLEpat (x_TUPLEpat);
 673 }
 674 Pat_EXTUPLEpat::Pat_EXTUPLEpat (a_List<Pat> *  x_EXTUPLEpat)
 675  : a_Pat(tag_EXTUPLEpat), EXTUPLEpat(x_EXTUPLEpat)
 676 {
 677 }
 678 a_Pat * EXTUPLEpat (a_List<Pat> *  x_EXTUPLEpat)
 679 {
 680    return new Pat_EXTUPLEpat (x_EXTUPLEpat);
 681 }
 682 Pat_RECORDpat::Pat_RECORDpat (a_List<LabPat> *  x_1, Bool x_2)
 683  : a_Pat(tag_RECORDpat), _1(x_1), _2(x_2)
 684 {
 685 }
 686 a_Pat * RECORDpat (a_List<LabPat> *  x_1, Bool x_2)
 687 {
 688    return new Pat_RECORDpat (x_1, x_2);
 689 }
 690 Pat_LISTpat::Pat_LISTpat (Cons x_cons, Cons x_nil, a_List<Pat> *  x_head, Pat x_tail)
 691  : a_Pat(tag_LISTpat), cons(x_cons), nil(x_nil), head(x_head), tail(x_tail)
 692 {
 693 }
 694 a_Pat * LISTpat (Cons x_cons, Cons x_nil, a_List<Pat> *  x_head, Pat x_tail)
 695 {
 696    return new Pat_LISTpat (x_cons, x_nil, x_head, x_tail);
 697 }
 698 Pat_VECTORpat::Pat_VECTORpat (Cons x_cons, Pat x_len, Pat x_array, a_List<Pat> *  x_elements, Bool x_head_flex, Bool x_tail_flex)
 699  : a_Pat(tag_VECTORpat), cons(x_cons), len(x_len), array(x_array), elements(x_elements), head_flex(x_head_flex), tail_flex(x_tail_flex)
 700 {
 701 }
 702 a_Pat * VECTORpat (Cons x_cons, Pat x_len, Pat x_array, a_List<Pat> *  x_elements, Bool x_head_flex, Bool x_tail_flex)
 703 {
 704    return new Pat_VECTORpat (x_cons, x_len, x_array, x_elements, x_head_flex, x_tail_flex);
 705 }
 706 Pat_APPENDpat::Pat_APPENDpat (Pat x_1, Pat x_2, Ty x_3)
 707  : a_Pat(tag_APPENDpat), _1(x_1), _2(x_2), _3(x_3)
 708 {
 709 }
 710 a_Pat * APPENDpat (Pat x_1, Pat x_2, Ty x_3)
 711 {
 712    return new Pat_APPENDpat (x_1, x_2, x_3);
 713 }
 714 Pat_GUARDpat::Pat_GUARDpat (Pat x_1, Exp x_2)
 715  : a_Pat(tag_GUARDpat), _1(x_1), _2(x_2)
 716 {
 717 }
 718 a_Pat * GUARDpat (Pat x_1, Exp x_2)
 719 {
 720    return new Pat_GUARDpat (x_1, x_2);
 721 }
 722 Pat_LOGICALpat::Pat_LOGICALpat (LogicalPat x_1, Pat x_2, Pat x_3)
 723  : a_Pat(tag_LOGICALpat), _1(x_1), _2(x_2), _3(x_3)
 724 {
 725 }
 726 a_Pat * LOGICALpat (LogicalPat x_1, Pat x_2, Pat x_3)
 727 {
 728    return new Pat_LOGICALpat (x_1, x_2, x_3);
 729 }
 730 Pat_BACKEDGEpat::Pat_BACKEDGEpat (int x_1, Id x_2, Pat x_3)
 731  : a_Pat(tag_BACKEDGEpat), _1(x_1), _2(x_2), _3(x_3)
 732 {
 733 }
 734 a_Pat * BACKEDGEpat (int x_1, Id x_2, Pat x_3)
 735 {
 736    return new Pat_BACKEDGEpat (x_1, x_2, x_3);
 737 }
 738 Pat_UNIFYpat::Pat_UNIFYpat (Pat x_1, Exp x_2)
 739  : a_Pat(tag_UNIFYpat), _1(x_1), _2(x_2)
 740 {
 741 }
 742 a_Pat * UNIFYpat (Pat x_1, Exp x_2)
 743 {
 744    return new Pat_UNIFYpat (x_1, x_2);
 745 }
 746 Pat_MARKEDpat::Pat_MARKEDpat (Loc x_1, Pat x_2)
 747  : a_Pat(tag_MARKEDpat), _1(x_1), _2(x_2)
 748 {
 749 }
 750 a_Pat * MARKEDpat (Loc x_1, Pat x_2)
 751 {
 752    return new Pat_MARKEDpat (x_1, x_2);
 753 }
 754
 755
 756 ///////////////////////////////////////////////////////////////////////////////
 757 //
 758 // Instantiation of datatype Exp
 759 //
 760 ///////////////////////////////////////////////////////////////////////////////
 761 #line 11 "constr.pcc"
 762 Exp_LITERALexp::Exp_LITERALexp (Literal x_LITERALexp)
 763  : a_Exp(tag_LITERALexp), LITERALexp(x_LITERALexp)
 764 {
 765 }
 766 a_Exp * LITERALexp (Literal x_LITERALexp)
 767 {
 768    return new Exp_LITERALexp (x_LITERALexp);
 769 }
 770 Exp_IDexp::Exp_IDexp (Id x_IDexp)
 771  : a_Exp(tag_IDexp), IDexp(x_IDexp)
 772 {
 773 }
 774 a_Exp * IDexp (Id x_IDexp)
 775 {
 776    return new Exp_IDexp (x_IDexp);
 777 }
 778 Exp_RELexp::Exp_RELexp (int x_RELexp)
 779  : a_Exp(tag_RELexp), RELexp(x_RELexp)
 780 {
 781 }
 782 a_Exp * RELexp (int x_RELexp)
 783 {
 784    return new Exp_RELexp (x_RELexp);
 785 }
 786 Exp_DOTexp::Exp_DOTexp (Exp x_1, Id x_2)
 787  : a_Exp(tag_DOTexp), _1(x_1), _2(x_2)
 788 {
 789 }
 790 a_Exp * DOTexp (Exp x_1, Id x_2)
 791 {
 792    return new Exp_DOTexp (x_1, x_2);
 793 }
 794 Exp_SELECTORexp::Exp_SELECTORexp (Exp x_1, Cons x_2, Ty x_3)
 795  : a_Exp(tag_SELECTORexp), _1(x_1), _2(x_2), _3(x_3)
 796 {
 797 }
 798 a_Exp * SELECTORexp (Exp x_1, Cons x_2, Ty x_3)
 799 {
 800    return new Exp_SELECTORexp (x_1, x_2, x_3);
 801 }
 802 Exp_DEREFexp::Exp_DEREFexp (Exp x_DEREFexp)
 803  : a_Exp(tag_DEREFexp), DEREFexp(x_DEREFexp)
 804 {
 805 }
 806 a_Exp * DEREFexp (Exp x_DEREFexp)
 807 {
 808    return new Exp_DEREFexp (x_DEREFexp);
 809 }
 810 Exp_ARROWexp::Exp_ARROWexp (Exp x_1, Id x_2)
 811  : a_Exp(tag_ARROWexp), _1(x_1), _2(x_2)
 812 {
 813 }
 814 a_Exp * ARROWexp (Exp x_1, Id x_2)
 815 {
 816    return new Exp_ARROWexp (x_1, x_2);
 817 }
 818 Exp_INDEXexp::Exp_INDEXexp (Exp x_1, Exp x_2)
 819  : a_Exp(tag_INDEXexp), _1(x_1), _2(x_2)
 820 {
 821 }
 822 a_Exp * INDEXexp (Exp x_1, Exp x_2)
 823 {
 824    return new Exp_INDEXexp (x_1, x_2);
 825 }
 826 Exp_BINOPexp::Exp_BINOPexp (Id x_1, Exp x_2, Exp x_3)
 827  : a_Exp(tag_BINOPexp), _1(x_1), _2(x_2), _3(x_3)
 828 {
 829 }
 830 a_Exp * BINOPexp (Id x_1, Exp x_2, Exp x_3)
 831 {
 832    return new Exp_BINOPexp (x_1, x_2, x_3);
 833 }
 834 Exp_PREFIXexp::Exp_PREFIXexp (Id x_1, Exp x_2)
 835  : a_Exp(tag_PREFIXexp), _1(x_1), _2(x_2)
 836 {
 837 }
 838 a_Exp * PREFIXexp (Id x_1, Exp x_2)
 839 {
 840    return new Exp_PREFIXexp (x_1, x_2);
 841 }
 842 Exp_POSTFIXexp::Exp_POSTFIXexp (Id x_1, Exp x_2)
 843  : a_Exp(tag_POSTFIXexp), _1(x_1), _2(x_2)
 844 {
 845 }
 846 a_Exp * POSTFIXexp (Id x_1, Exp x_2)
 847 {
 848    return new Exp_POSTFIXexp (x_1, x_2);
 849 }
 850 Exp_APPexp::Exp_APPexp (Exp x_1, Exp x_2)
 851  : a_Exp(tag_APPexp), _1(x_1), _2(x_2)
 852 {
 853 }
 854 a_Exp * APPexp (Exp x_1, Exp x_2)
 855 {
 856    return new Exp_APPexp (x_1, x_2);
 857 }
 858 Exp_ASSIGNexp::Exp_ASSIGNexp (Exp x_1, Exp x_2)
 859  : a_Exp(tag_ASSIGNexp), _1(x_1), _2(x_2)
 860 {
 861 }
 862 a_Exp * ASSIGNexp (Exp x_1, Exp x_2)
 863 {
 864    return new Exp_ASSIGNexp (x_1, x_2);
 865 }
 866 Exp_IFexp::Exp_IFexp (Exp x_1, Exp x_2, Exp x_3)
 867  : a_Exp(tag_IFexp), _1(x_1), _2(x_2), _3(x_3)
 868 {
 869 }
 870 a_Exp * IFexp (Exp x_1, Exp x_2, Exp x_3)
 871 {
 872    return new Exp_IFexp (x_1, x_2, x_3);
 873 }
 874 Exp_TUPLEexp::Exp_TUPLEexp (a_List<Exp> *  x_TUPLEexp)
 875  : a_Exp(tag_TUPLEexp), TUPLEexp(x_TUPLEexp)
 876 {
 877 }
 878 a_Exp * TUPLEexp (a_List<Exp> *  x_TUPLEexp)
 879 {
 880    return new Exp_TUPLEexp (x_TUPLEexp);
 881 }
 882 Exp_EXTUPLEexp::Exp_EXTUPLEexp (a_List<Exp> *  x_EXTUPLEexp)
 883  : a_Exp(tag_EXTUPLEexp), EXTUPLEexp(x_EXTUPLEexp)
 884 {
 885 }
 886 a_Exp * EXTUPLEexp (a_List<Exp> *  x_EXTUPLEexp)
 887 {
 888    return new Exp_EXTUPLEexp (x_EXTUPLEexp);
 889 }
 890 Exp_RECORDexp::Exp_RECORDexp (a_List<LabExp> *  x_RECORDexp)
 891  : a_Exp(tag_RECORDexp), RECORDexp(x_RECORDexp)
 892 {
 893 }
 894 a_Exp * RECORDexp (a_List<LabExp> *  x_RECORDexp)
 895 {
 896    return new Exp_RECORDexp (x_RECORDexp);
 897 }
 898 Exp_LISTexp::Exp_LISTexp (Cons x_1, Cons x_2, a_List<Exp> *  x_3, Exp x_4)
 899  : a_Exp(tag_LISTexp), _1(x_1), _2(x_2), _3(x_3), _4(x_4)
 900 {
 901 }
 902 a_Exp * LISTexp (Cons x_1, Cons x_2, a_List<Exp> *  x_3, Exp x_4)
 903 {
 904    return new Exp_LISTexp (x_1, x_2, x_3, x_4);
 905 }
 906 Exp_VECTORexp::Exp_VECTORexp (Cons x_1, a_List<Exp> *  x_2)
 907  : a_Exp(tag_VECTORexp), _1(x_1), _2(x_2)
 908 {
 909 }
 910 a_Exp * VECTORexp (Cons x_1, a_List<Exp> *  x_2)
 911 {
 912    return new Exp_VECTORexp (x_1, x_2);
 913 }
 914 Exp_CONSexp::Exp_CONSexp (Cons x_1, a_List<Exp> *  x_2, Exp x_3)
 915  : a_Exp(tag_CONSexp), _1(x_1), _2(x_2), _3(x_3)
 916 {
 917 }
 918 a_Exp * CONSexp (Cons x_1, a_List<Exp> *  x_2, Exp x_3)
 919 {
 920    return new Exp_CONSexp (x_1, x_2, x_3);
 921 }
 922 Exp_CASTexp::Exp_CASTexp (Ty x_1, Exp x_2)
 923  : a_Exp(tag_CASTexp), _1(x_1), _2(x_2)
 924 {
 925 }
 926 a_Exp * CASTexp (Ty x_1, Exp x_2)
 927 {
 928    return new Exp_CASTexp (x_1, x_2);
 929 }
 930 Exp_QUALexp::Exp_QUALexp (Ty x_1, Id x_2)
 931  : a_Exp(tag_QUALexp), _1(x_1), _2(x_2)
 932 {
 933 }
 934 a_Exp * QUALexp (Ty x_1, Id x_2)
 935 {
 936    return new Exp_QUALexp (x_1, x_2);
 937 }
 938 Exp_EQexp::Exp_EQexp (Ty x_1, Exp x_2, Exp x_3)
 939  : a_Exp(tag_EQexp), _1(x_1), _2(x_2), _3(x_3)
 940 {
 941 }
 942 a_Exp * EQexp (Ty x_1, Exp x_2, Exp x_3)
 943 {
 944    return new Exp_EQexp (x_1, x_2, x_3);
 945 }
 946 Exp_UNIFYexp::Exp_UNIFYexp (Ty x_1, Exp x_2, Exp x_3)
 947  : a_Exp(tag_UNIFYexp), _1(x_1), _2(x_2), _3(x_3)
 948 {
 949 }
 950 a_Exp * UNIFYexp (Ty x_1, Exp x_2, Exp x_3)
 951 {
 952    return new Exp_UNIFYexp (x_1, x_2, x_3);
 953 }
 954 Exp_LTexp::Exp_LTexp (Ty x_1, Exp x_2, Exp x_3)
 955  : a_Exp(tag_LTexp), _1(x_1), _2(x_2), _3(x_3)
 956 {
 957 }
 958 a_Exp * LTexp (Ty x_1, Exp x_2, Exp x_3)
 959 {
 960    return new Exp_LTexp (x_1, x_2, x_3);
 961 }
 962 Exp_HASHexp::Exp_HASHexp (Ty x_1, Exp x_2)
 963  : a_Exp(tag_HASHexp), _1(x_1), _2(x_2)
 964 {
 965 }
 966 a_Exp * HASHexp (Ty x_1, Exp x_2)
 967 {
 968    return new Exp_HASHexp (x_1, x_2);
 969 }
 970 Exp_THISCOSTexp::Exp_THISCOSTexp ()
 971  : a_Exp(tag_THISCOSTexp)
 972 {
 973 }
 974 a_Exp * THISCOSTexp ()
 975 {
 976    return new Exp_THISCOSTexp ;
 977 }
 978 Exp_COSTexp::Exp_COSTexp (ChildNo x_COSTexp)
 979  : a_Exp(tag_COSTexp), COSTexp(x_COSTexp)
 980 {
 981 }
 982 a_Exp * COSTexp (ChildNo x_COSTexp)
 983 {
 984    return new Exp_COSTexp (x_COSTexp);
 985 }
 986 Exp_THISSYNexp::Exp_THISSYNexp (RuleNo x_1, Ty x_2, Bool x_3)
 987  : a_Exp(tag_THISSYNexp), _1(x_1), _2(x_2), _3(x_3)
 988 {
 989 }
 990 a_Exp * THISSYNexp (RuleNo x_1, Ty x_2, Bool x_3)
 991 {
 992    return new Exp_THISSYNexp (x_1, x_2, x_3);
 993 }
 994 Exp_SYNexp::Exp_SYNexp (ChildNo x_1, RuleNo x_2, Ty x_3, Bool x_4)
 995  : a_Exp(tag_SYNexp), _1(x_1), _2(x_2), _3(x_3), _4(x_4)
 996 {
 997 }
 998 a_Exp * SYNexp (ChildNo x_1, RuleNo x_2, Ty x_3, Bool x_4)
 999 {
1000    return new Exp_SYNexp (x_1, x_2, x_3, x_4);
1001 }
1002 Exp_SENDexp::Exp_SENDexp (Id x_1, a_List<Exp> *  x_2)
1003  : a_Exp(tag_SENDexp), _1(x_1), _2(x_2)
1004 {
1005 }
1006 a_Exp * SENDexp (Id x_1, a_List<Exp> *  x_2)
1007 {
1008    return new Exp_SENDexp (x_1, x_2);
1009 }
1010 Exp_SETLexp::Exp_SETLexp (SETLOp x_1, Exps x_2)
1011  : a_Exp(tag_SETLexp), _1(x_1), _2(x_2)
1012 {
1013 }
1014 a_Exp * SETLexp (SETLOp x_1, Exps x_2)
1015 {
1016    return new Exp_SETLexp (x_1, x_2);
1017 }
1018 Exp_LISTCOMPexp::Exp_LISTCOMPexp (Exp x_exp, a_List<Generator> *  x_generators, Exp x_guard)
1019  : a_Exp(tag_LISTCOMPexp), exp(x_exp), generators(x_generators), guard(x_guard)
1020 {
1021 }
1022 a_Exp * LISTCOMPexp (Exp x_exp, a_List<Generator> *  x_generators, Exp x_guard)
1023 {
1024    return new Exp_LISTCOMPexp (x_exp, x_generators, x_guard);
1025 }
1026 Exp_FORALLexp::Exp_FORALLexp (Id x_1, Exp x_2)
1027  : a_Exp(tag_FORALLexp), _1(x_1), _2(x_2)
1028 {
1029 }
1030 a_Exp * FORALLexp (Id x_1, Exp x_2)
1031 {
1032    return new Exp_FORALLexp (x_1, x_2);
1033 }
1034 Exp_EXISTSexp::Exp_EXISTSexp (Id x_1, Exp x_2)
1035  : a_Exp(tag_EXISTSexp), _1(x_1), _2(x_2)
1036 {
1037 }
1038 a_Exp * EXISTSexp (Id x_1, Exp x_2)
1039 {
1040    return new Exp_EXISTSexp (x_1, x_2);
1041 }
1042 Exp_MARKEDexp::Exp_MARKEDexp (Loc x_1, Exp x_2)
1043  : a_Exp(tag_MARKEDexp), _1(x_1), _2(x_2)
1044 {
1045 }
1046 a_Exp * MARKEDexp (Loc x_1, Exp x_2)
1047 {
1048    return new Exp_MARKEDexp (x_1, x_2);
1049 }
1050
1051
1052 ///////////////////////////////////////////////////////////////////////////////
1053 //
1054 // Instantiation of datatype Cons
1055 //
1056 ///////////////////////////////////////////////////////////////////////////////
1057 #line 11 "constr.pcc"
1058 a_Cons::a_Cons (Id x_name, Ty x_alg_ty, Ty x_cons_ty, Ty x_ty, int x_tag, PrintFormats x_print_formats, Loc const * x_location, a_List<Inherit> *  x_inherit, a_List<Decl> *  x_body, TyOpt x_opt, TyQual x_qual, Exp x_view_predicate, Exp * x_view_selectors, Pat x_lexeme_pattern, DatatypeClass * x_class_def)
1059  : name(x_name), alg_ty(x_alg_ty), cons_ty(x_cons_ty), ty(x_ty), tag(x_tag), print_formats(x_print_formats), location(x_location), inherit(x_inherit), body(x_body), opt(x_opt), qual(x_qual), view_predicate(x_view_predicate), view_selectors(x_view_selectors), lexeme_pattern(x_lexeme_pattern), class_def(x_class_def)
1060 {
1061 }
1062 a_Cons * ONEcons (Id x_name, Ty x_alg_ty, Ty x_cons_ty, Ty x_ty, int x_tag, PrintFormats x_print_formats, Loc const * x_location, a_List<Inherit> *  x_inherit, a_List<Decl> *  x_body, TyOpt x_opt, TyQual x_qual, Exp x_view_predicate, Exp * x_view_selectors, Pat x_lexeme_pattern, DatatypeClass * x_class_def)
1063 {
1064    return new a_Cons (x_name, x_alg_ty, x_cons_ty, x_ty, x_tag, x_print_formats, x_location, x_inherit, x_body, x_opt, x_qual, x_view_predicate, x_view_selectors, x_lexeme_pattern, x_class_def);
1065 }
1066
1067
1068 ///////////////////////////////////////////////////////////////////////////////
1069 //
1070 // Instantiation of datatype Pos
1071 //
1072 ///////////////////////////////////////////////////////////////////////////////
1073 #line 11 "constr.pcc"
1074 Pos_POSint::Pos_POSint (int x_1, Pos x_2)
1075  : _1(x_1), _2(x_2)
1076 {
1077 }
1078 a_Pos * POSint (int x_1, Pos x_2)
1079 {
1080    return (a_Pos*)((unsigned long)(new Pos_POSint (x_1, x_2))|a_Pos::tag_POSint);
1081 }
1082 Pos_POSlabel::Pos_POSlabel (Id x_1, Pos x_2)
1083  : _1(x_1), _2(x_2)
1084 {
1085 }
1086 a_Pos * POSlabel (Id x_1, Pos x_2)
1087 {
1088    return (a_Pos*)((unsigned long)(new Pos_POSlabel (x_1, x_2))|a_Pos::tag_POSlabel);
1089 }
1090 Pos_POSadaptive::Pos_POSadaptive (int x_1, int * x_2, Pos x_3)
1091  : _1(x_1), _2(x_2), _3(x_3)
1092 {
1093 }
1094 a_Pos * POSadaptive (int x_1, int * x_2, Pos x_3)
1095 {
1096    return (a_Pos*)((unsigned long)(new Pos_POSadaptive (x_1, x_2, x_3))|a_Pos::tag_POSadaptive);
1097 }
1098
1099
1100 ///////////////////////////////////////////////////////////////////////////////
1101 //
1102 // Instantiation of datatype Match
1103 //
1104 ///////////////////////////////////////////////////////////////////////////////
1105 #line 11 "constr.pcc"
1106 Match_SUCCESSmatch::Match_SUCCESSmatch (int x_1, MatchRule x_2)
1107  : a_Match(tag_SUCCESSmatch), _1(x_1), _2(x_2)
1108 {
1109 }
1110 a_Match * SUCCESSmatch (int x_1, MatchRule x_2)
1111 {
1112    return new Match_SUCCESSmatch (x_1, x_2);
1113 }
1114 Match_SUCCESSESmatch::Match_SUCCESSESmatch (int x_1, BitSet * x_2, MatchRules x_3)
1115  : a_Match(tag_SUCCESSESmatch), _1(x_1), _2(x_2), _3(x_3)
1116 {
1117 }
1118 a_Match * SUCCESSESmatch (int x_1, BitSet * x_2, MatchRules x_3)
1119 {
1120    return new Match_SUCCESSESmatch (x_1, x_2, x_3);
1121 }
1122 Match_COSTmatch::Match_COSTmatch (int x_1, Cost * x_2, BitSet * x_3, MatchRules x_4)
1123  : a_Match(tag_COSTmatch), _1(x_1), _2(x_2), _3(x_3), _4(x_4)
1124 {
1125 }
1126 a_Match * COSTmatch (int x_1, Cost * x_2, BitSet * x_3, MatchRules x_4)
1127 {
1128    return new Match_COSTmatch (x_1, x_2, x_3, x_4);
1129 }
1130 Match_GUARDmatch::Match_GUARDmatch (Exp x_1, Match x_2, Match x_3)
1131  : a_Match(tag_GUARDmatch), _1(x_1), _2(x_2), _3(x_3)
1132 {
1133 }
1134 a_Match * GUARDmatch (Exp x_1, Match x_2, Match x_3)
1135 {
1136    return new Match_GUARDmatch (x_1, x_2, x_3);
1137 }
1138 Match_LITERALmatch::Match_LITERALmatch (Pos x_1, Exp x_2, Literal * x_3, int x_4, Match * x_5, Match x_6)
1139  : a_Match(tag_LITERALmatch), _1(x_1), _2(x_2), _3(x_3), _4(x_4), _5(x_5), _6(x_6)
1140 {
1141 }
1142 a_Match * LITERALmatch (Pos x_1, Exp x_2, Literal * x_3, int x_4, Match * x_5, Match x_6)
1143 {
1144    return new Match_LITERALmatch (x_1, x_2, x_3, x_4, x_5, x_6);
1145 }
1146 Match_RANGEmatch::Match_RANGEmatch (Pos x_1, Exp x_2, int x_3, int x_4, Match x_5, Match x_6)
1147  : a_Match(tag_RANGEmatch), _1(x_1), _2(x_2), _3(x_3), _4(x_4), _5(x_5), _6(x_6)
1148 {
1149 }
1150 a_Match * RANGEmatch (Pos x_1, Exp x_2, int x_3, int x_4, Match x_5, Match x_6)
1151 {
1152    return new Match_RANGEmatch (x_1, x_2, x_3, x_4, x_5, x_6);
1153 }
1154 Match_CONSmatch::Match_CONSmatch (Pos x_1, Exp x_2, Ty x_3, Ty x_4, int x_5, Match * x_6, Match x_7)
1155  : a_Match(tag_CONSmatch), _1(x_1), _2(x_2), _3(x_3), _4(x_4), _5(x_5), _6(x_6), _7(x_7)
1156 {
1157 }
1158 a_Match * CONSmatch (Pos x_1, Exp x_2, Ty x_3, Ty x_4, int x_5, Match * x_6, Match x_7)
1159 {
1160    return new Match_CONSmatch (x_1, x_2, x_3, x_4, x_5, x_6, x_7);
1161 }
1162 Match_TREECOSTmatch::Match_TREECOSTmatch (Match x_1, BitSet * x_2, MatchRules x_3)
1163  : a_Match(tag_TREECOSTmatch), _1(x_1), _2(x_2), _3(x_3)
1164 {
1165 }
1166 a_Match * TREECOSTmatch (Match x_1, BitSet * x_2, MatchRules x_3)
1167 {
1168    return new Match_TREECOSTmatch (x_1, x_2, x_3);
1169 }
1170 Match_TREELABELmatch::Match_TREELABELmatch (Match x_1, Ty x_2, Ty x_3, int x_4)
1171  : a_Match(tag_TREELABELmatch), _1(x_1), _2(x_2), _3(x_3), _4(x_4)
1172 {
1173 }
1174 a_Match * TREELABELmatch (Match x_1, Ty x_2, Ty x_3, int x_4)
1175 {
1176    return new Match_TREELABELmatch (x_1, x_2, x_3, x_4);
1177 }
1178 Match_BACKEDGEmatch::Match_BACKEDGEmatch (int x_1, Id x_2, Match x_3)
1179  : a_Match(tag_BACKEDGEmatch), _1(x_1), _2(x_2), _3(x_3)
1180 {
1181 }
1182 a_Match * BACKEDGEmatch (int x_1, Id x_2, Match x_3)
1183 {
1184    return new Match_BACKEDGEmatch (x_1, x_2, x_3);
1185 }
1186
1187
1188 ///////////////////////////////////////////////////////////////////////////////
1189 //
1190 // Instantiation of datatype Decl
1191 //
1192 ///////////////////////////////////////////////////////////////////////////////
1193 #line 11 "constr.pcc"
1194 Decl_OPAQUEdecl::Decl_OPAQUEdecl (char const * x_OPAQUEdecl)
1195  : a_Decl(tag_OPAQUEdecl), OPAQUEdecl(x_OPAQUEdecl)
1196 {
1197 }
1198 a_Decl * OPAQUEdecl (char const * x_OPAQUEdecl)
1199 {
1200    return new Decl_OPAQUEdecl (x_OPAQUEdecl);
1201 }
1202 Decl_DATATYPEdecl::Decl_DATATYPEdecl (DatatypeDefs x_1, ViewDefs x_2, LawDefs x_3, TyDefs x_4)
1203  : a_Decl(tag_DATATYPEdecl), _1(x_1), _2(x_2), _3(x_3), _4(x_4)
1204 {
1205 }
1206 a_Decl * DATATYPEdecl (DatatypeDefs x_1, ViewDefs x_2, LawDefs x_3, TyDefs x_4)
1207 {
1208    return new Decl_DATATYPEdecl (x_1, x_2, x_3, x_4);
1209 }
1210 Decl_INSTANTIATEdecl::Decl_INSTANTIATEdecl (Bool x_1, Tys x_2)
1211  : a_Decl(tag_INSTANTIATEdecl), _1(x_1), _2(x_2)
1212 {
1213 }
1214 a_Decl * INSTANTIATEdecl (Bool x_1, Tys x_2)
1215 {
1216    return new Decl_INSTANTIATEdecl (x_1, x_2);
1217 }
1218 Decl_CLASSDEFdecl::Decl_CLASSDEFdecl (ClassDefinition * x_CLASSDEFdecl)
1219  : a_Decl(tag_CLASSDEFdecl), CLASSDEFdecl(x_CLASSDEFdecl)
1220 {
1221 }
1222 a_Decl * CLASSDEFdecl (ClassDefinition * x_CLASSDEFdecl)
1223 {
1224    return new Decl_CLASSDEFdecl (x_CLASSDEFdecl);
1225 }
1226 Decl_INFERENCEdecl::Decl_INFERENCEdecl (Id x_1, InferenceRules x_2)
1227  : a_Decl(tag_INFERENCEdecl), _1(x_1), _2(x_2)
1228 {
1229 }
1230 a_Decl * INFERENCEdecl (Id x_1, InferenceRules x_2)
1231 {
1232    return new Decl_INFERENCEdecl (x_1, x_2);
1233 }
1234 Decl_REWRITEdecl::Decl_REWRITEdecl (Id x_1, RewriteIndexings x_2, MatchRules x_3)
1235  : a_Decl(tag_REWRITEdecl), _1(x_1), _2(x_2), _3(x_3)
1236 {
1237 }
1238 a_Decl * REWRITEdecl (Id x_1, RewriteIndexings x_2, MatchRules x_3)
1239 {
1240    return new Decl_REWRITEdecl (x_1, x_2, x_3);
1241 }
1242 Decl_REWRITINGdecl::Decl_REWRITINGdecl (Protocols x_1, Exp x_2, Exp x_3, RewriteIndexings x_4, MatchRules x_5, TyQual x_6)
1243  : a_Decl(tag_REWRITINGdecl), _1(x_1), _2(x_2), _3(x_3), _4(x_4), _5(x_5), _6(x_6)
1244 {
1245 }
1246 a_Decl * REWRITINGdecl (Protocols x_1, Exp x_2, Exp x_3, RewriteIndexings x_4, MatchRules x_5, TyQual x_6)
1247 {
1248    return new Decl_REWRITINGdecl (x_1, x_2, x_3, x_4, x_5, x_6);
1249 }
1250 Decl_REPLACEMENTdecl::Decl_REPLACEMENTdecl (Exp x_1, MatchRuleInfo::RewritingMode x_2)
1251  : a_Decl(tag_REPLACEMENTdecl), _1(x_1), _2(x_2)
1252 {
1253 }
1254 a_Decl * REPLACEMENTdecl (Exp x_1, MatchRuleInfo::RewritingMode x_2)
1255 {
1256    return new Decl_REPLACEMENTdecl (x_1, x_2);
1257 }
1258 Decl_CUTREWRITEdecl::Decl_CUTREWRITEdecl (Exp x_1, MatchRuleInfo::RewritingMode x_2)
1259  : a_Decl(tag_CUTREWRITEdecl), _1(x_1), _2(x_2)
1260 {
1261 }
1262 a_Decl * CUTREWRITEdecl (Exp x_1, MatchRuleInfo::RewritingMode x_2)
1263 {
1264    return new Decl_CUTREWRITEdecl (x_1, x_2);
1265 }
1266 Decl_FAILREWRITEdecl::Decl_FAILREWRITEdecl (MatchRuleInfo::RewritingMode x_FAILREWRITEdecl)
1267  : a_Decl(tag_FAILREWRITEdecl), FAILREWRITEdecl(x_FAILREWRITEdecl)
1268 {
1269 }
1270 a_Decl * FAILREWRITEdecl (MatchRuleInfo::RewritingMode x_FAILREWRITEdecl)
1271 {
1272    return new Decl_FAILREWRITEdecl (x_FAILREWRITEdecl);
1273 }
1274 Decl_INJECTdecl::Decl_INJECTdecl (int x_node_number, EntryDirection x_direction)
1275  : a_Decl(tag_INJECTdecl), node_number(x_node_number), direction(x_direction)
1276 {
1277 }
1278 a_Decl * INJECTdecl (int x_node_number, EntryDirection x_direction)
1279 {
1280    return new Decl_INJECTdecl (x_node_number, x_direction);
1281 }
1282 Decl_GOTOdecl::Decl_GOTOdecl (Id x_GOTOdecl)
1283  : a_Decl(tag_GOTOdecl), GOTOdecl(x_GOTOdecl)
1284 {
1285 }
1286 a_Decl * GOTOdecl (Id x_GOTOdecl)
1287 {
1288    return new Decl_GOTOdecl (x_GOTOdecl);
1289 }
1290 Decl_SETSTATEdecl::Decl_SETSTATEdecl (int x_SETSTATEdecl)
1291  : a_Decl(tag_SETSTATEdecl), SETSTATEdecl(x_SETSTATEdecl)
1292 {
1293 }
1294 a_Decl * SETSTATEdecl (int x_SETSTATEdecl)
1295 {
1296    return new Decl_SETSTATEdecl (x_SETSTATEdecl);
1297 }
1298 Decl_CONSTRAINTdecl::Decl_CONSTRAINTdecl (Id x_1, ConstraintSet x_2)
1299  : a_Decl(tag_CONSTRAINTdecl), _1(x_1), _2(x_2)
1300 {
1301 }
1302 a_Decl * CONSTRAINTdecl (Id x_1, ConstraintSet x_2)
1303 {
1304    return new Decl_CONSTRAINTdecl (x_1, x_2);
1305 }
1306 Decl_SYNTAXdecl::Decl_SYNTAXdecl (Id x_1, GramExp x_2)
1307  : a_Decl(tag_SYNTAXdecl), _1(x_1), _2(x_2)
1308 {
1309 }
1310 a_Decl * SYNTAXdecl (Id x_1, GramExp x_2)
1311 {
1312    return new Decl_SYNTAXdecl (x_1, x_2);
1313 }
1314 Decl_ATTRIBUTEGRAMMARdecl::Decl_ATTRIBUTEGRAMMARdecl (Id x_1, GramExp x_2)
1315  : a_Decl(tag_ATTRIBUTEGRAMMARdecl), _1(x_1), _2(x_2)
1316 {
1317 }
1318 a_Decl * ATTRIBUTEGRAMMARdecl (Id x_1, GramExp x_2)
1319 {
1320    return new Decl_ATTRIBUTEGRAMMARdecl (x_1, x_2);
1321 }
1322 Decl_FUNdecl::Decl_FUNdecl (FunDefs x_FUNdecl)
1323  : a_Decl(tag_FUNdecl), FUNdecl(x_FUNdecl)
1324 {
1325 }
1326 a_Decl * FUNdecl (FunDefs x_FUNdecl)
1327 {
1328    return new Decl_FUNdecl (x_FUNdecl);
1329 }
1330 Decl_MATCHdecl::Decl_MATCHdecl (MatchExps x_1, MatchRules x_2, MatchOptions x_3, Ty x_4)
1331  : a_Decl(tag_MATCHdecl), _1(x_1), _2(x_2), _3(x_3), _4(x_4)
1332 {
1333 }
1334 a_Decl * MATCHdecl (MatchExps x_1, MatchRules x_2, MatchOptions x_3, Ty x_4)
1335 {
1336    return new Decl_MATCHdecl (x_1, x_2, x_3, x_4);
1337 }
1338 Decl_BITFIELDdecl::Decl_BITFIELDdecl (Id x_name, int x_width, FieldDefs x_field_names, FieldLaws x_laws)
1339  : a_Decl(tag_BITFIELDdecl), name(x_name), width(x_width), field_names(x_field_names), laws(x_laws)
1340 {
1341 }
1342 a_Decl * BITFIELDdecl (Id x_name, int x_width, FieldDefs x_field_names, FieldLaws x_laws)
1343 {
1344    return new Decl_BITFIELDdecl (x_name, x_width, x_field_names, x_laws);
1345 }
1346 Decl_SETLSTMTdecl::Decl_SETLSTMTdecl (Stmt x_SETLSTMTdecl)
1347  : a_Decl(tag_SETLSTMTdecl), SETLSTMTdecl(x_SETLSTMTdecl)
1348 {
1349 }
1350 a_Decl * SETLSTMTdecl (Stmt x_SETLSTMTdecl)
1351 {
1352    return new Decl_SETLSTMTdecl (x_SETLSTMTdecl);
1353 }
1354 Decl_SETLDEFdecl::Decl_SETLDEFdecl (Def x_SETLDEFdecl)
1355  : a_Decl(tag_SETLDEFdecl), SETLDEFdecl(x_SETLDEFdecl)
1356 {
1357 }
1358 a_Decl * SETLDEFdecl (Def x_SETLDEFdecl)
1359 {
1360    return new Decl_SETLDEFdecl (x_SETLDEFdecl);
1361 }
1362 Decl_GRAPHREWRITEdecl::Decl_GRAPHREWRITEdecl (Id x_name, LabTys x_args, GraphRewritingRules x_rules)
1363  : a_Decl(tag_GRAPHREWRITEdecl), name(x_name), args(x_args), rules(x_rules)
1364 {
1365 }
1366 a_Decl * GRAPHREWRITEdecl (Id x_name, LabTys x_args, GraphRewritingRules x_rules)
1367 {
1368    return new Decl_GRAPHREWRITEdecl (x_name, x_args, x_rules);
1369 }
1370 Decl_DATAFLOWdecl::Decl_DATAFLOWdecl (Id x_name)
1371  : a_Decl(tag_DATAFLOWdecl), name(x_name)
1372 {
1373 }
1374 a_Decl * DATAFLOWdecl (Id x_name)
1375 {
1376    return new Decl_DATAFLOWdecl (x_name);
1377 }
1378 Decl_CLASSOFdecl::Decl_CLASSOFdecl (Id x_CLASSOFdecl)
1379  : a_Decl(tag_CLASSOFdecl), CLASSOFdecl(x_CLASSOFdecl)
1380 {
1381 }
1382 a_Decl * CLASSOFdecl (Id x_CLASSOFdecl)
1383 {
1384    return new Decl_CLASSOFdecl (x_CLASSOFdecl);
1385 }
1386 Decl_TYPEEXPdecl::Decl_TYPEEXPdecl (Ty x_TYPEEXPdecl)
1387  : a_Decl(tag_TYPEEXPdecl), TYPEEXPdecl(x_TYPEEXPdecl)
1388 {
1389 }
1390 a_Decl * TYPEEXPdecl (Ty x_TYPEEXPdecl)
1391 {
1392    return new Decl_TYPEEXPdecl (x_TYPEEXPdecl);
1393 }
1394 Decl_EXPdecl::Decl_EXPdecl (Exp x_exp, char const * x_prefix, char const * x_suffix)
1395  : a_Decl(tag_EXPdecl), exp(x_exp), prefix(x_prefix), suffix(x_suffix)
1396 {
1397 }
1398 a_Decl * EXPdecl (Exp x_exp, char const * x_prefix, char const * x_suffix)
1399 {
1400    return new Decl_EXPdecl (x_exp, x_prefix, x_suffix);
1401 }
1402 Decl_MARKEDdecl::Decl_MARKEDdecl (Loc x_1, Decl x_2)
1403  : a_Decl(tag_MARKEDdecl), _1(x_1), _2(x_2)
1404 {
1405 }
1406 a_Decl * MARKEDdecl (Loc x_1, Decl x_2)
1407 {
1408    return new Decl_MARKEDdecl (x_1, x_2);
1409 }
1410
1411
1412 ///////////////////////////////////////////////////////////////////////////////
1413 //
1414 // Instantiation of datatype MatchExp
1415 //
1416 ///////////////////////////////////////////////////////////////////////////////
1417 #line 11 "constr.pcc"
1418 a_MatchExp::a_MatchExp (Exp x_1, Id x_2)
1419  : _1(x_1), _2(x_2)
1420 {
1421 }
1422 a_MatchExp * MATCHexp (Exp x_1, Id x_2)
1423 {
1424    return new a_MatchExp (x_1, x_2);
1425 }
1426
1427
1428 ///////////////////////////////////////////////////////////////////////////////
1429 //
1430 // Instantiation of datatype Inherit
1431 //
1432 ///////////////////////////////////////////////////////////////////////////////
1433 #line 11 "constr.pcc"
1434 a_Inherit::a_Inherit (Ty x_super_class, Scope x_scope, TyQual x_qualifiers)
1435  : super_class(x_super_class), scope(x_scope), qualifiers(x_qualifiers)
1436 {
1437 }
1438 a_Inherit * INHERIT (Ty x_super_class, Scope x_scope, TyQual x_qualifiers)
1439 {
1440    return new a_Inherit (x_super_class, x_scope, x_qualifiers);
1441 }
1442
1443
1444 ///////////////////////////////////////////////////////////////////////////////
1445 //
1446 // Instantiation of datatype Literal
1447 //
1448 ///////////////////////////////////////////////////////////////////////////////
1449 #line 11 "constr.pcc"
1450 Literal_INTlit::Literal_INTlit (int x_INTlit)
1451  : a_Literal(tag_INTlit), INTlit(x_INTlit)
1452 {
1453 }
1454 a_Literal * INTlit (int x_INTlit)
1455 {
1456    return new Literal_INTlit (x_INTlit);
1457 }
1458 Literal_BOOLlit::Literal_BOOLlit (Bool x_BOOLlit)
1459  : a_Literal(tag_BOOLlit), BOOLlit(x_BOOLlit)
1460 {
1461 }
1462 a_Literal * BOOLlit (Bool x_BOOLlit)
1463 {
1464    return new Literal_BOOLlit (x_BOOLlit);
1465 }
1466 Literal_CHARlit::Literal_CHARlit (char x_CHARlit)
1467  : a_Literal(tag_CHARlit), CHARlit(x_CHARlit)
1468 {
1469 }
1470 a_Literal * CHARlit (char x_CHARlit)
1471 {
1472    return new Literal_CHARlit (x_CHARlit);
1473 }
1474 Literal_REALlit::Literal_REALlit (double x_REALlit)
1475  : a_Literal(tag_REALlit), REALlit(x_REALlit)
1476 {
1477 }
1478 a_Literal * REALlit (double x_REALlit)
1479 {
1480    return new Literal_REALlit (x_REALlit);
1481 }
1482 Literal_STRINGlit::Literal_STRINGlit (char const * x_STRINGlit)
1483  : a_Literal(tag_STRINGlit), STRINGlit(x_STRINGlit)
1484 {
1485 }
1486 a_Literal * STRINGlit (char const * x_STRINGlit)
1487 {
1488    return new Literal_STRINGlit (x_STRINGlit);
1489 }
1490 Literal_REGEXPlit::Literal_REGEXPlit (char const * x_REGEXPlit)
1491  : a_Literal(tag_REGEXPlit), REGEXPlit(x_REGEXPlit)
1492 {
1493 }
1494 a_Literal * REGEXPlit (char const * x_REGEXPlit)
1495 {
1496    return new Literal_REGEXPlit (x_REGEXPlit);
1497 }
1498 Literal_QUARKlit::Literal_QUARKlit (char const * x_QUARKlit)
1499  : a_Literal(tag_QUARKlit), QUARKlit(x_QUARKlit)
1500 {
1501 }
1502 a_Literal * QUARKlit (char const * x_QUARKlit)
1503 {
1504    return new Literal_QUARKlit (x_QUARKlit);
1505 }
1506 Literal_BIGINTlit::Literal_BIGINTlit (char const * x_BIGINTlit)
1507  : a_Literal(tag_BIGINTlit), BIGINTlit(x_BIGINTlit)
1508 {
1509 }
1510 a_Literal * BIGINTlit (char const * x_BIGINTlit)
1511 {
1512    return new Literal_BIGINTlit (x_BIGINTlit);
1513 }
1514
1515
1516 ///////////////////////////////////////////////////////////////////////////////
1517 //
1518 // Instantiation of datatype Cost
1519 //
1520 ///////////////////////////////////////////////////////////////////////////////
1521 #line 11 "constr.pcc"
1522 Cost_EXPcost::Cost_EXPcost (Exp x_1, Ty x_2)
1523  : _1(x_1), _2(x_2)
1524 {
1525 }
1526 a_Cost * EXPcost (Exp x_1, Ty x_2)
1527 {
1528    return (a_Cost*)((unsigned long)(new Cost_EXPcost (x_1, x_2))|a_Cost::tag_EXPcost);
1529 }
1530 Cost_INTcost::Cost_INTcost (int x_INTcost)
1531  : INTcost(x_INTcost)
1532 {
1533 }
1534 a_Cost * INTcost (int x_INTcost)
1535 {
1536    return (a_Cost*)((unsigned long)(new Cost_INTcost (x_INTcost))|a_Cost::tag_INTcost);
1537 }
1538
1539
1540 ///////////////////////////////////////////////////////////////////////////////
1541 //
1542 // Instantiation of datatype MatchRule
1543 //
1544 ///////////////////////////////////////////////////////////////////////////////
1545 #line 11 "constr.pcc"
1546 a_MatchRule::a_MatchRule (Id x_1, Pat x_2, Exp x_3, Cost x_4, a_List<Decl> *  x_5)
1547  : _1(x_1), _2(x_2), _3(x_3), _4(x_4), _5(x_5)
1548 {
1549 }
1550 a_MatchRule * MATCHrule (Id x_1, Pat x_2, Exp x_3, Cost x_4, a_List<Decl> *  x_5)
1551 {
1552    return new a_MatchRule (x_1, x_2, x_3, x_4, x_5);
1553 }
1554
1555
1556 ///////////////////////////////////////////////////////////////////////////////
1557 //
1558 // Instantiation of datatype Protocol
1559 //
1560 ///////////////////////////////////////////////////////////////////////////////
1561 #line 11 "constr.pcc"
1562 a_Protocol::a_Protocol (Ty x_ty, Ty x_inh, Ty x_syn)
1563  : ty(x_ty), inh(x_inh), syn(x_syn)
1564 {
1565 }
1566 a_Protocol * PROTOCOL (Ty x_ty, Ty x_inh, Ty x_syn)
1567 {
1568    return new a_Protocol (x_ty, x_inh, x_syn);
1569 }
1570
1571
1572 ///////////////////////////////////////////////////////////////////////////////
1573 //
1574 // Instantiation of datatype DatatypeDef
1575 //
1576 ///////////////////////////////////////////////////////////////////////////////
1577 #line 11 "constr.pcc"
1578 a_DatatypeDef::a_DatatypeDef (Id x_1, TyVars x_2, Inherits x_3, TyQual x_4, TermDefs x_5, Decls x_6)
1579  : _1(x_1), _2(x_2), _3(x_3), _4(x_4), _5(x_5), _6(x_6)
1580 {
1581 }
1582 a_DatatypeDef * DATATYPEdef (Id x_1, TyVars x_2, Inherits x_3, TyQual x_4, TermDefs x_5, Decls x_6)
1583 {
1584    return new a_DatatypeDef (x_1, x_2, x_3, x_4, x_5, x_6);
1585 }
1586
1587
1588 ///////////////////////////////////////////////////////////////////////////////
1589 //
1590 // Instantiation of datatype TyDef
1591 //
1592 ///////////////////////////////////////////////////////////////////////////////
1593 #line 11 "constr.pcc"
1594 a_TyDef::a_TyDef (Id x_1, TyVars x_2, Ty x_3, Bool x_4)
1595  : _1(x_1), _2(x_2), _3(x_3), _4(x_4)
1596 {
1597 }
1598 a_TyDef * TYdef (Id x_1, TyVars x_2, Ty x_3, Bool x_4)
1599 {
1600    return new a_TyDef (x_1, x_2, x_3, x_4);
1601 }
1602
1603
1604 ///////////////////////////////////////////////////////////////////////////////
1605 //
1606 // Instantiation of datatype TermDef
1607 //
1608 ///////////////////////////////////////////////////////////////////////////////
1609 #line 11 "constr.pcc"
1610 a_TermDef::a_TermDef (Id x_id, Ty x_ty, Decls x_decls, Inherits x_inherits, Pat x_pat, PrintFormats x_print_formats, TyOpt x_opt, TyQual x_qual, Exp x_view_predicate)
1611  : id(x_id), ty(x_ty), decls(x_decls), inherits(x_inherits), pat(x_pat), print_formats(x_print_formats), opt(x_opt), qual(x_qual), view_predicate(x_view_predicate)
1612 {
1613 }
1614 a_TermDef * TERMdef (Id x_id, Ty x_ty, Decls x_decls, Inherits x_inherits, Pat x_pat, PrintFormats x_print_formats, TyOpt x_opt, TyQual x_qual, Exp x_view_predicate)
1615 {
1616    return new a_TermDef (x_id, x_ty, x_decls, x_inherits, x_pat, x_print_formats, x_opt, x_qual, x_view_predicate);
1617 }
1618
1619
1620 ///////////////////////////////////////////////////////////////////////////////
1621 //
1622 // Instantiation of datatype ViewDef
1623 //
1624 ///////////////////////////////////////////////////////////////////////////////
1625 #line 11 "constr.pcc"
1626 a_ViewDef::a_ViewDef (Pat x_1, Exp x_2, a_List<LabExp> *  x_3)
1627  : _1(x_1), _2(x_2), _3(x_3)
1628 {
1629 }
1630 a_ViewDef * VIEWdef (Pat x_1, Exp x_2, a_List<LabExp> *  x_3)
1631 {
1632    return new a_ViewDef (x_1, x_2, x_3);
1633 }
1634
1635
1636 ///////////////////////////////////////////////////////////////////////////////
1637 //
1638 // Instantiation of datatype LawDef
1639 //
1640 ///////////////////////////////////////////////////////////////////////////////
1641 #line 11 "constr.pcc"
1642 a_LawDef::a_LawDef (Id x_id, Ids x_args, Exp x_guard, Pat x_pat, Bool x_invert, Ty x_ty)
1643  : id(x_id), args(x_args), guard(x_guard), pat(x_pat), invert(x_invert), ty(x_ty)
1644 {
1645 }
1646 a_LawDef * LAWdef (Id x_id, Ids x_args, Exp x_guard, Pat x_pat, Bool x_invert, Ty x_ty)
1647 {
1648    return new a_LawDef (x_id, x_args, x_guard, x_pat, x_invert, x_ty);
1649 }
1650
1651
1652 ///////////////////////////////////////////////////////////////////////////////
1653 //
1654 // Instantiation of datatype FunDef
1655 //
1656 ///////////////////////////////////////////////////////////////////////////////
1657 #line 11 "constr.pcc"
1658 a_FunDef::a_FunDef (QualId x_1, Ty x_2, Ty x_3, MatchRules x_4)
1659  : _1(x_1), _2(x_2), _3(x_3), _4(x_4)
1660 {
1661 }
1662 a_FunDef * FUNdef (QualId x_1, Ty x_2, Ty x_3, MatchRules x_4)
1663 {
1664    return new a_FunDef (x_1, x_2, x_3, x_4);
1665 }
1666
1667
1668 ///////////////////////////////////////////////////////////////////////////////
1669 //
1670 // Instantiation of datatype QualId
1671 //
1672 ///////////////////////////////////////////////////////////////////////////////
1673 #line 11 "constr.pcc"
1674 QualId_NESTEDid::QualId_NESTEDid (Ty x_1, QualId x_2)
1675  : _1(x_1), _2(x_2)
1676 {
1677 }
1678 a_QualId * NESTEDid (Ty x_1, QualId x_2)
1679 {
1680    return (a_QualId*)((unsigned long)(new QualId_NESTEDid (x_1, x_2))|a_QualId::tag_NESTEDid);
1681 }
1682 QualId_SIMPLEid::QualId_SIMPLEid (Id x_SIMPLEid)
1683  : SIMPLEid(x_SIMPLEid)
1684 {
1685 }
1686 a_QualId * SIMPLEid (Id x_SIMPLEid)
1687 {
1688    return (a_QualId*)((unsigned long)(new QualId_SIMPLEid (x_SIMPLEid))|a_QualId::tag_SIMPLEid);
1689 }
1690
1691
1692 ///////////////////////////////////////////////////////////////////////////////
1693 //
1694 // Instantiation of datatype InferenceRule
1695 //
1696 ///////////////////////////////////////////////////////////////////////////////
1697 #line 11 "constr.pcc"
1698 a_InferenceRule::a_InferenceRule (MatchRules x_1, Exp x_2, Conclusions x_3)
1699  : _1(x_1), _2(x_2), _3(x_3)
1700 {
1701 }
1702 a_InferenceRule * INFERENCErule (MatchRules x_1, Exp x_2, Conclusions x_3)
1703 {
1704    return new a_InferenceRule (x_1, x_2, x_3);
1705 }
1706
1707
1708 ///////////////////////////////////////////////////////////////////////////////
1709 //
1710 // Instantiation of datatype Conclusion
1711 //
1712 ///////////////////////////////////////////////////////////////////////////////
1713 #line 11 "constr.pcc"
1714 Conclusion_ASSERTaction::Conclusion_ASSERTaction (Exp x_ASSERTaction)
1715  : ASSERTaction(x_ASSERTaction)
1716 {
1717 }
1718 a_Conclusion * ASSERTaction (Exp x_ASSERTaction)
1719 {
1720    return (a_Conclusion*)((unsigned long)(new Conclusion_ASSERTaction (x_ASSERTaction))|a_Conclusion::tag_ASSERTaction);
1721 }
1722 Conclusion_RETRACTaction::Conclusion_RETRACTaction (Exp x_RETRACTaction)
1723  : RETRACTaction(x_RETRACTaction)
1724 {
1725 }
1726 a_Conclusion * RETRACTaction (Exp x_RETRACTaction)
1727 {
1728    return (a_Conclusion*)((unsigned long)(new Conclusion_RETRACTaction (x_RETRACTaction))|a_Conclusion::tag_RETRACTaction);
1729 }
1730 Conclusion_STMTaction::Conclusion_STMTaction (Decls x_STMTaction)
1731  : STMTaction(x_STMTaction)
1732 {
1733 }
1734 a_Conclusion * STMTaction (Decls x_STMTaction)
1735 {
1736    return (a_Conclusion*)((unsigned long)(new Conclusion_STMTaction (x_STMTaction))|a_Conclusion::tag_STMTaction);
1737 }
1738
1739
1740 ///////////////////////////////////////////////////////////////////////////////
1741 //
1742 // Instantiation of datatype LogicalPat
1743 //
1744 ///////////////////////////////////////////////////////////////////////////////
1745 #line 11 "constr.pcc"
1746
1747
1748 ///////////////////////////////////////////////////////////////////////////////
1749 //
1750 // Instantiation of datatype Scope
1751 //
1752 ///////////////////////////////////////////////////////////////////////////////
1753 #line 11 "constr.pcc"
1754
1755
1756 ///////////////////////////////////////////////////////////////////////////////
1757 //
1758 // Instantiation of datatype Polarity
1759 //
1760 ///////////////////////////////////////////////////////////////////////////////
1761 #line 11 "constr.pcc"
1762
1763
1764 ///////////////////////////////////////////////////////////////////////////////
1765 //
1766 // Instantiation of datatype List<Ty>
1767 //
1768 ///////////////////////////////////////////////////////////////////////////////
1769 #line 11 "constr.pcc"
1770 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
1771 template class a_List<Ty>;
1772 template a_List<Ty> * list_1_(RewriteIndexing * x_1, a_List<RewriteIndexing *> *  x_2);
1773 template a_List<Ty> * list_1_(RewriteIndexing * x_list_1_);
1774 template int boxed(const a_List<Ty> *);
1775 template int untag(const a_List<Ty> *);
1776 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
1777
1778 ///////////////////////////////////////////////////////////////////////////////
1779 //
1780 // Instantiation of datatype List<Pat>
1781 //
1782 ///////////////////////////////////////////////////////////////////////////////
1783 #line 11 "constr.pcc"
1784 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
1785 template class a_List<Pat>;
1786 template a_List<Pat> * list_1_(Ty x_1, a_List<Ty> *  x_2);
1787 template a_List<Pat> * list_1_(Ty x_list_1_);
1788 template int boxed(const a_List<Pat> *);
1789 template int untag(const a_List<Pat> *);
1790 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
1791
1792 ///////////////////////////////////////////////////////////////////////////////
1793 //
1794 // Instantiation of datatype List<Exp>
1795 //
1796 ///////////////////////////////////////////////////////////////////////////////
1797 #line 11 "constr.pcc"
1798 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
1799 template class a_List<Exp>;
1800 template a_List<Exp> * list_1_(Pat x_1, a_List<Pat> *  x_2);
1801 template a_List<Exp> * list_1_(Pat x_list_1_);
1802 template int boxed(const a_List<Exp> *);
1803 template int untag(const a_List<Exp> *);
1804 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
1805
1806 ///////////////////////////////////////////////////////////////////////////////
1807 //
1808 // Instantiation of datatype List<Pos>
1809 //
1810 ///////////////////////////////////////////////////////////////////////////////
1811 #line 11 "constr.pcc"
1812 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
1813 template class a_List<Pos>;
1814 template a_List<Pos> * list_1_(Exp x_1, a_List<Exp> *  x_2);
1815 template a_List<Pos> * list_1_(Exp x_list_1_);
1816 template int boxed(const a_List<Pos> *);
1817 template int untag(const a_List<Pos> *);
1818 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
1819
1820 ///////////////////////////////////////////////////////////////////////////////
1821 //
1822 // Instantiation of datatype List<Decl>
1823 //
1824 ///////////////////////////////////////////////////////////////////////////////
1825 #line 11 "constr.pcc"
1826 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
1827 template class a_List<Decl>;
1828 template a_List<Decl> * list_1_(Pos x_1, a_List<Pos> *  x_2);
1829 template a_List<Decl> * list_1_(Pos x_list_1_);
1830 template int boxed(const a_List<Decl> *);
1831 template int untag(const a_List<Decl> *);
1832 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
1833
1834 ///////////////////////////////////////////////////////////////////////////////
1835 //
1836 // Instantiation of datatype List<Inherit>
1837 //
1838 ///////////////////////////////////////////////////////////////////////////////
1839 #line 11 "constr.pcc"
1840 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
1841 template class a_List<Inherit>;
1842 template a_List<Inherit> * list_1_(Decl x_1, a_List<Decl> *  x_2);
1843 template a_List<Inherit> * list_1_(Decl x_list_1_);
1844 template int boxed(const a_List<Inherit> *);
1845 template int untag(const a_List<Inherit> *);
1846 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
1847
1848 ///////////////////////////////////////////////////////////////////////////////
1849 //
1850 // Instantiation of datatype List<MatchExp>
1851 //
1852 ///////////////////////////////////////////////////////////////////////////////
1853 #line 11 "constr.pcc"
1854 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
1855 template class a_List<MatchExp>;
1856 template a_List<MatchExp> * list_1_(Inherit x_1, a_List<Inherit> *  x_2);
1857 template a_List<MatchExp> * list_1_(Inherit x_list_1_);
1858 template int boxed(const a_List<MatchExp> *);
1859 template int untag(const a_List<MatchExp> *);
1860 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
1861
1862 ///////////////////////////////////////////////////////////////////////////////
1863 //
1864 // Instantiation of datatype List<MatchRule>
1865 //
1866 ///////////////////////////////////////////////////////////////////////////////
1867 #line 11 "constr.pcc"
1868 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
1869 template class a_List<MatchRule>;
1870 template a_List<MatchRule> * list_1_(MatchExp x_1, a_List<MatchExp> *  x_2);
1871 template a_List<MatchRule> * list_1_(MatchExp x_list_1_);
1872 template int boxed(const a_List<MatchRule> *);
1873 template int untag(const a_List<MatchRule> *);
1874 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
1875
1876 ///////////////////////////////////////////////////////////////////////////////
1877 //
1878 // Instantiation of datatype List<Protocol>
1879 //
1880 ///////////////////////////////////////////////////////////////////////////////
1881 #line 11 "constr.pcc"
1882 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
1883 template class a_List<Protocol>;
1884 template a_List<Protocol> * list_1_(MatchRule x_1, a_List<MatchRule> *  x_2);
1885 template a_List<Protocol> * list_1_(MatchRule x_list_1_);
1886 template int boxed(const a_List<Protocol> *);
1887 template int untag(const a_List<Protocol> *);
1888 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
1889
1890 ///////////////////////////////////////////////////////////////////////////////
1891 //
1892 // Instantiation of datatype List<DatatypeDef>
1893 //
1894 ///////////////////////////////////////////////////////////////////////////////
1895 #line 11 "constr.pcc"
1896 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
1897 template class a_List<DatatypeDef>;
1898 template a_List<DatatypeDef> * list_1_(Protocol x_1, a_List<Protocol> *  x_2);
1899 template a_List<DatatypeDef> * list_1_(Protocol x_list_1_);
1900 template int boxed(const a_List<DatatypeDef> *);
1901 template int untag(const a_List<DatatypeDef> *);
1902 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
1903
1904 ///////////////////////////////////////////////////////////////////////////////
1905 //
1906 // Instantiation of datatype List<TyDef>
1907 //
1908 ///////////////////////////////////////////////////////////////////////////////
1909 #line 11 "constr.pcc"
1910 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
1911 template class a_List<TyDef>;
1912 template a_List<TyDef> * list_1_(DatatypeDef x_1, a_List<DatatypeDef> *  x_2);
1913 template a_List<TyDef> * list_1_(DatatypeDef x_list_1_);
1914 template int boxed(const a_List<TyDef> *);
1915 template int untag(const a_List<TyDef> *);
1916 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
1917
1918 ///////////////////////////////////////////////////////////////////////////////
1919 //
1920 // Instantiation of datatype List<TermDef>
1921 //
1922 ///////////////////////////////////////////////////////////////////////////////
1923 #line 11 "constr.pcc"
1924 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
1925 template class a_List<TermDef>;
1926 template a_List<TermDef> * list_1_(TyDef x_1, a_List<TyDef> *  x_2);
1927 template a_List<TermDef> * list_1_(TyDef x_list_1_);
1928 template int boxed(const a_List<TermDef> *);
1929 template int untag(const a_List<TermDef> *);
1930 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
1931
1932 ///////////////////////////////////////////////////////////////////////////////
1933 //
1934 // Instantiation of datatype List<ViewDef>
1935 //
1936 ///////////////////////////////////////////////////////////////////////////////
1937 #line 11 "constr.pcc"
1938 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
1939 template class a_List<ViewDef>;
1940 template a_List<ViewDef> * list_1_(TermDef x_1, a_List<TermDef> *  x_2);
1941 template a_List<ViewDef> * list_1_(TermDef x_list_1_);
1942 template int boxed(const a_List<ViewDef> *);
1943 template int untag(const a_List<ViewDef> *);
1944 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
1945
1946 ///////////////////////////////////////////////////////////////////////////////
1947 //
1948 // Instantiation of datatype List<LawDef>
1949 //
1950 ///////////////////////////////////////////////////////////////////////////////
1951 #line 11 "constr.pcc"
1952 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
1953 template class a_List<LawDef>;
1954 template a_List<LawDef> * list_1_(ViewDef x_1, a_List<ViewDef> *  x_2);
1955 template a_List<LawDef> * list_1_(ViewDef x_list_1_);
1956 template int boxed(const a_List<LawDef> *);
1957 template int untag(const a_List<LawDef> *);
1958 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
1959
1960 ///////////////////////////////////////////////////////////////////////////////
1961 //
1962 // Instantiation of datatype List<FunDef>
1963 //
1964 ///////////////////////////////////////////////////////////////////////////////
1965 #line 11 "constr.pcc"
1966 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
1967 template class a_List<FunDef>;
1968 template a_List<FunDef> * list_1_(LawDef x_1, a_List<LawDef> *  x_2);
1969 template a_List<FunDef> * list_1_(LawDef x_list_1_);
1970 template int boxed(const a_List<FunDef> *);
1971 template int untag(const a_List<FunDef> *);
1972 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
1973
1974 ///////////////////////////////////////////////////////////////////////////////
1975 //
1976 // Instantiation of datatype List<QualId>
1977 //
1978 ///////////////////////////////////////////////////////////////////////////////
1979 #line 11 "constr.pcc"
1980 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
1981 template class a_List<QualId>;
1982 template a_List<QualId> * list_1_(FunDef x_1, a_List<FunDef> *  x_2);
1983 template a_List<QualId> * list_1_(FunDef x_list_1_);
1984 template int boxed(const a_List<QualId> *);
1985 template int untag(const a_List<QualId> *);
1986 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
1987
1988 ///////////////////////////////////////////////////////////////////////////////
1989 //
1990 // Instantiation of datatype List<InferenceRule>
1991 //
1992 ///////////////////////////////////////////////////////////////////////////////
1993 #line 11 "constr.pcc"
1994 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
1995 template class a_List<InferenceRule>;
1996 template a_List<InferenceRule> * list_1_(QualId x_1, a_List<QualId> *  x_2);
1997 template a_List<InferenceRule> * list_1_(QualId x_list_1_);
1998 template int boxed(const a_List<InferenceRule> *);
1999 template int untag(const a_List<InferenceRule> *);
2000 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
2001
2002 ///////////////////////////////////////////////////////////////////////////////
2003 //
2004 // Instantiation of datatype List<Conclusion>
2005 //
2006 ///////////////////////////////////////////////////////////////////////////////
2007 #line 11 "constr.pcc"
2008 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
2009 template class a_List<Conclusion>;
2010 template a_List<Conclusion> * list_1_(InferenceRule x_1, a_List<InferenceRule> *  x_2);
2011 template a_List<Conclusion> * list_1_(InferenceRule x_list_1_);
2012 template int boxed(const a_List<Conclusion> *);
2013 template int untag(const a_List<Conclusion> *);
2014 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
2015
2016 ///////////////////////////////////////////////////////////////////////////////
2017 //
2018 // Instantiation of datatype List<Scope>
2019 //
2020 ///////////////////////////////////////////////////////////////////////////////
2021 #line 11 "constr.pcc"
2022 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
2023 template class a_List<Scope>;
2024 template a_List<Scope> * list_1_(Conclusion x_1, a_List<Conclusion> *  x_2);
2025 template a_List<Scope> * list_1_(Conclusion x_list_1_);
2026 template int boxed(const a_List<Scope> *);
2027 template int untag(const a_List<Scope> *);
2028 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
2029
2030 ///////////////////////////////////////////////////////////////////////////////
2031 //
2032 // Instantiation of datatype Pid
2033 //
2034 ///////////////////////////////////////////////////////////////////////////////
2035 #line 11 "constr.pcc"
2036 a_Pid::a_Pid (char const * x_PERSISTid)
2037  : PERSISTid(x_PERSISTid)
2038 {
2039 }
2040 a_Pid * PERSISTid (char const * x_PERSISTid)
2041 {
2042    return new a_Pid (x_PERSISTid);
2043 }
2044
2045
2046 ///////////////////////////////////////////////////////////////////////////////
2047 //
2048 // Instantiation of datatype Pair<Id, Tys>
2049 //
2050 ///////////////////////////////////////////////////////////////////////////////
2051 #line 11 "constr.pcc"
2052 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
2053 template class a_Pair<Id, Tys>;
2054 template a_Pair<Id, Tys> * pair(Id x_fst, Tys x_snd);
2055 template int boxed(const a_Pair<Id, Tys> *);
2056 template int untag(const a_Pair<Id, Tys> *);
2057 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
2058
2059 ///////////////////////////////////////////////////////////////////////////////
2060 //
2061 // Instantiation of datatype Generator
2062 //
2063 ///////////////////////////////////////////////////////////////////////////////
2064 #line 11 "constr.pcc"
2065 a_Generator::a_Generator (Pat x_pat, Exp x_guard, Exp x_exp)
2066  : pat(x_pat), guard(x_guard), exp(x_exp)
2067 {
2068 }
2069 a_Generator * GENERATOR (Pat x_pat, Exp x_guard, Exp x_exp)
2070 {
2071    return new a_Generator (x_pat, x_guard, x_exp);
2072 }
2073
2074
2075 ///////////////////////////////////////////////////////////////////////////////
2076 //
2077 // Instantiation of datatype List<Generator>
2078 //
2079 ///////////////////////////////////////////////////////////////////////////////
2080 #line 11 "constr.pcc"
2081 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
2082 template class a_List<Generator>;
2083 template a_List<Generator> * list_1_(Scope x_1, a_List<Scope> *  x_2);
2084 template a_List<Generator> * list_1_(Scope x_list_1_);
2085 template int boxed(const a_List<Generator> *);
2086 template int untag(const a_List<Generator> *);
2087 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
2088
2089 ///////////////////////////////////////////////////////////////////////////////
2090 //
2091 // Instantiation of datatype List<RewriteIndexing *>
2092 //
2093 ///////////////////////////////////////////////////////////////////////////////
2094 #line 11 "constr.pcc"
2095 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
2096 template class a_List<RewriteIndexing *>;
2097 template a_List<RewriteIndexing *> * list_1_(Generator x_1, a_List<Generator> *  x_2);
2098 template a_List<RewriteIndexing *> * list_1_(Generator x_list_1_);
2099 template int boxed(const a_List<RewriteIndexing *> *);
2100 template int untag(const a_List<RewriteIndexing *> *);
2101 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
2102
2103 #line 22 "constr.pcc"
2104 #line 22 "constr.pcc"
2105
2106 #line 23 "constr.pcc"
2107 /*
2108 ------------------------------- Statistics -------------------------------
2109 Merge matching rules         = yes
2110 Number of DFA nodes merged   = 0
2111 Number of ifs generated      = 0
2112 Number of switches generated = 0
2113 Number of labels             = 0
2114 Number of gotos              = 0
2115 Adaptive matching            = enabled
2116 Fast string matching         = disabled
2117 Inline downcasts             = enabled
2118 --------------------------------------------------------------------------
2119 */