prop-src/ir.h

   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 "ir.ph".
   5 ///////////////////////////////////////////////////////////////////////////////
   6
   7 #line 1 "ir.ph"
   8 ///////////////////////////////////////////////////////////////////////////////
   9 //
  10 //  This file contains the definitions for the intermediate data structures
  11 //  used within the Prop -> C++ translator.  Definitions for types, patterns,
  12 //  decision trees, and pretty printing formats are located here.
  13 //
  14 ///////////////////////////////////////////////////////////////////////////////
  15 #ifndef intermediate_representations_h
  16 #define intermediate_representations_h
  17
  18 #include "basics.h"
  19
  20 ///////////////////////////////////////////////////////////////////////////////
  21 //
  22 //  Forward datatype declarations
  23 //
  24 ///////////////////////////////////////////////////////////////////////////////
  25 #line 18 "ir.ph"
  26 #line 18 "ir.ph"
  27 ///////////////////////////////////////////////////////////////////////////////
  28 //
  29 // Forward class definition for Exp
  30 //
  31 ///////////////////////////////////////////////////////////////////////////////
  32 #ifndef datatype_Exp_defined
  33 #define datatype_Exp_defined
  34    class a_Exp;
  35    typedef a_Exp * Exp;
  36 #endif
  37
  38 ///////////////////////////////////////////////////////////////////////////////
  39 //
  40 // Forward class definition for Stmt
  41 //
  42 ///////////////////////////////////////////////////////////////////////////////
  43 #ifndef datatype_Stmt_defined
  44 #define datatype_Stmt_defined
  45    class a_Stmt;
  46    typedef a_Stmt * Stmt;
  47 #endif
  48
  49 ///////////////////////////////////////////////////////////////////////////////
  50 //
  51 // Forward class definition for Decl
  52 //
  53 ///////////////////////////////////////////////////////////////////////////////
  54 #ifndef datatype_Decl_defined
  55 #define datatype_Decl_defined
  56    class a_Decl;
  57    typedef a_Decl * Decl;
  58 #endif
  59
  60 ///////////////////////////////////////////////////////////////////////////////
  61 //
  62 // Forward class definition for MatchRule
  63 //
  64 ///////////////////////////////////////////////////////////////////////////////
  65 #ifndef datatype_MatchRule_defined
  66 #define datatype_MatchRule_defined
  67    class a_MatchRule;
  68    typedef a_MatchRule * MatchRule;
  69 #endif
  70
  71 ///////////////////////////////////////////////////////////////////////////////
  72 //
  73 // Forward class definition for CollectionDesc
  74 //
  75 ///////////////////////////////////////////////////////////////////////////////
  76 #ifndef datatype_CollectionDesc_defined
  77 #define datatype_CollectionDesc_defined
  78    class a_CollectionDesc;
  79    typedef a_CollectionDesc * CollectionDesc;
  80 #endif
  81
  82 #line 18 "ir.ph"
  83 #line 18 "ir.ph"
  84
  85
  86 class GraphTypeDef;
  87 class EdgeDef;
  88 class NodeDef;
  89 class DatatypeHierarchy;
  90 class DatatypeClass;
  91
  92 ///////////////////////////////////////////////////////////////////////////////
  93 //
  94 //  Qualifiers determines various implementation characteristics
  95 //  of the type.
  96 //
  97 ///////////////////////////////////////////////////////////////////////////////
  98 enum { QUALnone          = 0,      // no qualifiers
  99        QUALprintable     = 1<<0,   // pretty printable
 100        QUALtracable      = 1<<1,   // reference countable
 101        QUALcollectable   = 1<<2,   // garbage collectable
 102        QUALrewritable    = 1<<3,   // rewritable
 103        QUALrelation      = 1<<4,   // a relation
 104        QUALpersistent    = 1<<5,   // persistent type
 105        QUALclass         = 1<<6,   // class type
 106        QUALconst         = 1<<7,   // const
 107        QUALunsigned      = 1<<8,   // unsigned
 108        QUALsigned        = 1<<9,   // signed
 109        QUALvirtual       = 1<<10,  // virtual inheritance
 110        QUALextensible    = 1<<11,  // extensible type
 111        QUALview          = 1<<12,  // a view
 112        QUALunifiable     = 1<<13,  // an unifiable term
 113        QUALtaggedpointer = 1<<14,  // use tagged pointers for representation
 114        QUALunboxed       = 1<<15,  // use unboxed presentation if possible
 115        QUALfinalizable   = 1<<16,  // object should be finalized
 116        QUALapplicative   = 1<<17,  // applicative rewrite
 117        QUALtreeparser    = 1<<18,  // tree parsing
 118        QUALparser        = 1<<19,  // parser class
 119        QUALlexeme        = 1<<20,  // usable as tokens
 120        QUALbitfield      = 1<<21,  // an opcode or opcode bitfield
 121        QUALtopdown       = 1<<22,  // use topdown tree matching in rewriting
 122        QUALvariable      = 1<<23,  // unifiable variable
 123        QUALgraphtype     = 1<<24,  // a graph type
 124        QUALgraphnode     = 1<<25,  // a graph node
 125        QUALgraphedge     = 1<<26,  // a graph edge
 126        QUALvirtualdestr  = 1<<27,  // virtual destructor
 127        QUALinline        = 1<<28,  // inline methods
 128        QUALextern        = 1<<29   // noninline methods
 129      };
 130
 131 ///////////////////////////////////////////////////////////////////////////////
 132 //
 133 //  Optimization options
 134 //
 135 ///////////////////////////////////////////////////////////////////////////////
 136 enum { OPTnone          = 0,     // no optimization
 137        OPTtagless       = 1<<0,  // omit the embedded variant tag
 138        OPTsubclassless  = 1<<1,  // omit the subclass hierarchy
 139        OPTbaseclassless = 1<<2,  // omit inheritance from base class
 140        OPTtaggedpointer = 1<<3,  // embedded the variant tag in lower bits
 141                                  // of the pointer.
 142        OPTunboxed       = 1<<4,  // use unboxed representation if possible
 143        OPTtaggedvar     = 1<<5   // tagged variables
 144      };
 145
 146 ///////////////////////////////////////////////////////////////////////////////
 147 //
 148 //  Scoping
 149 //
 150 ///////////////////////////////////////////////////////////////////////////////
 151 #line 85 "ir.ph"
 152 #line 346 "ir.ph"
 153 enum Scope {
 154    PRIVATEscope = 0, PROTECTEDscope = 1, PUBLICscope = 2
 155 };
 156
 157
 158
 159 enum Parameter {
 160    TYbody = 0, TYformal = 1, TYsimpleformal = 2,
 161    TYactual = 3
 162 };
 163
 164
 165
 166 enum Polarity {
 167    ISpositive = 0, ISnegative = 1, ISneither = 2
 168 };
 169
 170
 171
 172 ///////////////////////////////////////////////////////////////////////////////
 173 //
 174 // Forward class definition for Ty
 175 //
 176 ///////////////////////////////////////////////////////////////////////////////
 177 #ifndef datatype_Ty_defined
 178 #define datatype_Ty_defined
 179    class a_Ty;
 180    typedef a_Ty * Ty;
 181 #endif
 182
 183 #  define NOty (Ty)0
 184
 185 ///////////////////////////////////////////////////////////////////////////////
 186 //
 187 // Forward class definition for TyCon
 188 //
 189 ///////////////////////////////////////////////////////////////////////////////
 190 #ifndef datatype_TyCon_defined
 191 #define datatype_TyCon_defined
 192    class a_TyCon;
 193    typedef a_TyCon * TyCon;
 194 #endif
 195
 196 #  define POINTERtycon (TyCon)0
 197 #  define REFtycon (TyCon)1
 198 #  define TUPLEtycon (TyCon)2
 199 #  define EXTUPLEtycon (TyCon)3
 200 #  define FUNtycon (TyCon)4
 201 #  define TYPEtycon (TyCon)5
 202
 203 ///////////////////////////////////////////////////////////////////////////////
 204 //
 205 // Forward class definition for Pat
 206 //
 207 ///////////////////////////////////////////////////////////////////////////////
 208 #ifndef datatype_Pat_defined
 209 #define datatype_Pat_defined
 210    class a_Pat;
 211    typedef a_Pat * Pat;
 212 #endif
 213
 214 #  define NOpat (Pat)0
 215
 216 enum LogicalPat {
 217    NOTpat = 0, ANDpat = 1, ORpat = 2,
 218    EQUIVpat = 3, XORpat = 4, IMPLIESpat = 5
 219 };
 220
 221
 222
 223 ///////////////////////////////////////////////////////////////////////////////
 224 //
 225 // Forward class definition for Literal
 226 //
 227 ///////////////////////////////////////////////////////////////////////////////
 228 #ifndef datatype_Literal_defined
 229 #define datatype_Literal_defined
 230    class a_Literal;
 231    typedef a_Literal * Literal;
 232 #endif
 233
 234 ///////////////////////////////////////////////////////////////////////////////
 235 //
 236 // Forward class definition for Cons
 237 //
 238 ///////////////////////////////////////////////////////////////////////////////
 239 #ifndef datatype_Cons_defined
 240 #define datatype_Cons_defined
 241    class a_Cons;
 242    typedef a_Cons * Cons;
 243 #endif
 244
 245 #  define NOcons (Cons)0
 246
 247 ///////////////////////////////////////////////////////////////////////////////
 248 //
 249 // Forward class definition for ProductionSymbol
 250 //
 251 ///////////////////////////////////////////////////////////////////////////////
 252 #ifndef datatype_ProductionSymbol_defined
 253 #define datatype_ProductionSymbol_defined
 254    class a_ProductionSymbol;
 255    typedef a_ProductionSymbol * ProductionSymbol;
 256 #endif
 257
 258 ///////////////////////////////////////////////////////////////////////////////
 259 //
 260 // Forward class definition for Pid
 261 //
 262 ///////////////////////////////////////////////////////////////////////////////
 263 #ifndef datatype_Pid_defined
 264 #define datatype_Pid_defined
 265    class a_Pid;
 266    typedef a_Pid * Pid;
 267 #endif
 268
 269 #  define PERSISTnone (Pid)0
 270
 271 ///////////////////////////////////////////////////////////////////////////////
 272 //
 273 // Forward class definition for Inherit
 274 //
 275 ///////////////////////////////////////////////////////////////////////////////
 276 #ifndef datatype_Inherit_defined
 277 #define datatype_Inherit_defined
 278    class a_Inherit;
 279    typedef a_Inherit * Inherit;
 280 #endif
 281
 282 ///////////////////////////////////////////////////////////////////////////////
 283 // Definition of type TyQual
 284 ///////////////////////////////////////////////////////////////////////////////
 285 #line 333 "ir.ph"
 286 typedef int TyQual;
 287
 288 ///////////////////////////////////////////////////////////////////////////////
 289 // Definition of type TyOpt
 290 ///////////////////////////////////////////////////////////////////////////////
 291 #line 334 "ir.ph"
 292 typedef int TyOpt;
 293
 294 ///////////////////////////////////////////////////////////////////////////////
 295 // Definition of type LabTy
 296 ///////////////////////////////////////////////////////////////////////////////
 297 #line 335 "ir.ph"
 298 typedef struct { Id label; Ty ty;  } LabTy;
 299
 300 ///////////////////////////////////////////////////////////////////////////////
 301 // Definition of type LabPat
 302 ///////////////////////////////////////////////////////////////////////////////
 303 #line 336 "ir.ph"
 304 typedef struct { Id label; Pat pat;  } LabPat;
 305
 306 ///////////////////////////////////////////////////////////////////////////////
 307 // Definition of type Inherits
 308 ///////////////////////////////////////////////////////////////////////////////
 309 #line 337 "ir.ph"
 310 typedef a_List<Inherit> *  Inherits;
 311
 312 ///////////////////////////////////////////////////////////////////////////////
 313 // Definition of type Conses
 314 ///////////////////////////////////////////////////////////////////////////////
 315 #line 338 "ir.ph"
 316 typedef a_List<Cons> *  Conses;
 317
 318 ///////////////////////////////////////////////////////////////////////////////
 319 // Definition of type Tys
 320 ///////////////////////////////////////////////////////////////////////////////
 321 #line 339 "ir.ph"
 322 typedef a_List<Ty> *  Tys;
 323
 324 ///////////////////////////////////////////////////////////////////////////////
 325 // Definition of type LabTys
 326 ///////////////////////////////////////////////////////////////////////////////
 327 #line 340 "ir.ph"
 328 typedef a_List<LabTy> *  LabTys;
 329
 330 ///////////////////////////////////////////////////////////////////////////////
 331 // Definition of type Pats
 332 ///////////////////////////////////////////////////////////////////////////////
 333 #line 341 "ir.ph"
 334 typedef a_List<Pat> *  Pats;
 335
 336 ///////////////////////////////////////////////////////////////////////////////
 337 // Definition of type LabPats
 338 ///////////////////////////////////////////////////////////////////////////////
 339 #line 342 "ir.ph"
 340 typedef a_List<LabPat> *  LabPats;
 341
 342 ///////////////////////////////////////////////////////////////////////////////
 343 // Definition of type TyVar
 344 ///////////////////////////////////////////////////////////////////////////////
 345 #line 343 "ir.ph"
 346 typedef Id TyVar;
 347
 348 ///////////////////////////////////////////////////////////////////////////////
 349 // Definition of type TyVars
 350 ///////////////////////////////////////////////////////////////////////////////
 351 #line 344 "ir.ph"
 352 typedef a_List<TyVar> *  TyVars;
 353
 354 ///////////////////////////////////////////////////////////////////////////////
 355 // Definition of type PrintFormats
 356 ///////////////////////////////////////////////////////////////////////////////
 357 #line 345 "ir.ph"
 358 typedef a_List<ProductionSymbol> *  PrintFormats;
 359
 360
 361
 362
 363 ///////////////////////////////////////////////////////////////////////////////
 364 //
 365 // Base class for datatype Ty
 366 //
 367 ///////////////////////////////////////////////////////////////////////////////
 368 class a_Ty : public MEM {
 369 public:
 370    enum Tag_Ty {
 371       tag_VARty = 0, tag_INDty = 1, tag_QUALty = 2,
 372       tag_TYCONty = 3, tag_POLYty = 4, tag_DEFVALty = 5,
 373       tag_NESTEDty = 6
 374    };
 375
 376 public:
 377    const Tag_Ty tag__; // variant tag
 378 protected:
 379    inline a_Ty(Tag_Ty t__) : tag__(t__) {}
 380 public:
 381 };
 382 inline int boxed(const a_Ty * x) { return x != 0; }
 383 inline int untag(const a_Ty * x) { return x ? (x->tag__+1) : 0; }
 384 ///////////////////////////////////////////////////////////////////////////////
 385 //
 386 // Class for datatype constructor Ty::VARty
 387 //
 388 ///////////////////////////////////////////////////////////////////////////////
 389 class Ty_VARty : public a_Ty {
 390 public:
 391 #line 119 "ir.ph"
 392    Ty VARty;
 393    Ty_VARty (Ty x_VARty);
 394 };
 395
 396 ///////////////////////////////////////////////////////////////////////////////
 397 //
 398 // Class for datatype constructor Ty::INDty
 399 //
 400 ///////////////////////////////////////////////////////////////////////////////
 401 class Ty_INDty : public a_Ty {
 402 public:
 403 #line 120 "ir.ph"
 404    Id _1; int _2;
 405    Ty_INDty (Id x_1, int x_2);
 406 };
 407
 408 ///////////////////////////////////////////////////////////////////////////////
 409 //
 410 // Class for datatype constructor Ty::QUALty
 411 //
 412 ///////////////////////////////////////////////////////////////////////////////
 413 class Ty_QUALty : public a_Ty {
 414 public:
 415 #line 121 "ir.ph"
 416    TyQual _1; Ty _2;
 417    Ty_QUALty (TyQual x_1, Ty x_2);
 418 };
 419
 420 ///////////////////////////////////////////////////////////////////////////////
 421 //
 422 // Class for datatype constructor Ty::TYCONty
 423 //
 424 ///////////////////////////////////////////////////////////////////////////////
 425 class Ty_TYCONty : public a_Ty {
 426 public:
 427 #line 122 "ir.ph"
 428    TyCon _1; a_List<Ty> *  _2;
 429    Ty_TYCONty (TyCon x_1, a_List<Ty> *  x_2);
 430 };
 431
 432 ///////////////////////////////////////////////////////////////////////////////
 433 //
 434 // Class for datatype constructor Ty::POLYty
 435 //
 436 ///////////////////////////////////////////////////////////////////////////////
 437 class Ty_POLYty : public a_Ty {
 438 public:
 439 #line 123 "ir.ph"
 440    Ty _1; int _2; TyVar * _3;
 441    Ty_POLYty (Ty x_1, int x_2, TyVar * x_3);
 442 };
 443
 444 ///////////////////////////////////////////////////////////////////////////////
 445 //
 446 // Class for datatype constructor Ty::DEFVALty
 447 //
 448 ///////////////////////////////////////////////////////////////////////////////
 449 class Ty_DEFVALty : public a_Ty {
 450 public:
 451 #line 124 "ir.ph"
 452    Ty _1; Exp _2;
 453    Ty_DEFVALty (Ty x_1, Exp x_2);
 454 };
 455
 456 ///////////////////////////////////////////////////////////////////////////////
 457 //
 458 // Class for datatype constructor Ty::NESTEDty
 459 //
 460 ///////////////////////////////////////////////////////////////////////////////
 461 class Ty_NESTEDty : public a_Ty {
 462 public:
 463 #line 125 "ir.ph"
 464    Ty _1; Ty _2;
 465    Ty_NESTEDty (Ty x_1, Ty x_2);
 466 };
 467
 468 ///////////////////////////////////////////////////////////////////////////////
 469 //
 470 // Datatype constructor functions for Ty
 471 //
 472 ///////////////////////////////////////////////////////////////////////////////
 473 extern a_Ty * VARty (Ty x_VARty);
 474 extern a_Ty * INDty (Id x_1, int x_2);
 475 extern a_Ty * QUALty (TyQual x_1, Ty x_2);
 476 extern a_Ty * TYCONty (TyCon x_1, a_List<Ty> *  x_2);
 477 extern a_Ty * POLYty (Ty x_1, int x_2, TyVar * x_3);
 478 extern a_Ty * DEFVALty (Ty x_1, Exp x_2);
 479 extern a_Ty * NESTEDty (Ty x_1, Ty x_2);
 480
 481 ///////////////////////////////////////////////////////////////////////////////
 482 //
 483 // Base class for datatype TyCon
 484 //
 485 ///////////////////////////////////////////////////////////////////////////////
 486 class a_TyCon : public MEM {
 487 public:
 488    enum Tag_TyCon {
 489       tag_IDtycon = 0, tag_RECORDtycon = 1, tag_ARRAYtycon = 2,
 490       tag_BITFIELDtycon = 3, tag_DATATYPEtycon = 4, tag_COLtycon = 5,
 491       tag_GRAPHtycon = 6, tag_NODEtycon = 7, tag_EDGEtycon = 8
 492    };
 493
 494 public:
 495    const Tag_TyCon tag__; // variant tag
 496 protected:
 497    inline a_TyCon(Tag_TyCon t__) : tag__(t__) {}
 498 public:
 499 };
 500 inline int boxed(const a_TyCon * x) { return (unsigned long)x >= 6; }
 501 inline int untag(const a_TyCon * x) { return boxed(x) ? x->tag__ + 6 : (int)x; }
 502 ///////////////////////////////////////////////////////////////////////////////
 503 //
 504 // Class for datatype constructor TyCon::IDtycon
 505 //
 506 ///////////////////////////////////////////////////////////////////////////////
 507 class TyCon_IDtycon : public a_TyCon {
 508 public:
 509 #line 135 "ir.ph"
 510    Id IDtycon;
 511    TyCon_IDtycon (Id x_IDtycon);
 512 };
 513
 514 ///////////////////////////////////////////////////////////////////////////////
 515 //
 516 // Class for datatype constructor TyCon::RECORDtycon
 517 //
 518 ///////////////////////////////////////////////////////////////////////////////
 519 class TyCon_RECORDtycon : public a_TyCon {
 520 public:
 521 #line 140 "ir.ph"
 522    a_List<Id> *  _1; Bool _2;
 523    TyCon_RECORDtycon (a_List<Id> *  x_1, Bool x_2);
 524 };
 525
 526 ///////////////////////////////////////////////////////////////////////////////
 527 //
 528 // Class for datatype constructor TyCon::ARRAYtycon
 529 //
 530 ///////////////////////////////////////////////////////////////////////////////
 531 class TyCon_ARRAYtycon : public a_TyCon {
 532 public:
 533 #line 141 "ir.ph"
 534    Exp ARRAYtycon;
 535    TyCon_ARRAYtycon (Exp x_ARRAYtycon);
 536 };
 537
 538 ///////////////////////////////////////////////////////////////////////////////
 539 //
 540 // Class for datatype constructor TyCon::BITFIELDtycon
 541 //
 542 ///////////////////////////////////////////////////////////////////////////////
 543 class TyCon_BITFIELDtycon : public a_TyCon {
 544 public:
 545 #line 142 "ir.ph"
 546    int width; Bool is_signed;
 547    TyCon_BITFIELDtycon (int x_width, Bool x_is_signed = false);
 548 };
 549
 550 ///////////////////////////////////////////////////////////////////////////////
 551 //
 552 // Class for datatype constructor TyCon::DATATYPEtycon
 553 //
 554 ///////////////////////////////////////////////////////////////////////////////
 555 class TyCon_DATATYPEtycon : public a_TyCon {
 556 public:
 557 #line 146 "ir.ph"
 558    Id id; int unit; int arg; Cons * terms; TyVars tyvars; Ty polyty; a_List<Inherit> *  inherit; TyQual qualifiers; TyOpt opt; a_List<Decl> *  body; Exp view_match; Loc const * location; DatatypeHierarchy * hierarchy;
 559    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 = 0);
 560 };
 561
 562 ///////////////////////////////////////////////////////////////////////////////
 563 //
 564 // Class for datatype constructor TyCon::COLtycon
 565 //
 566 ///////////////////////////////////////////////////////////////////////////////
 567 class TyCon_COLtycon : public a_TyCon {
 568 public:
 569 #line 161 "ir.ph"
 570    CollectionDesc COLtycon;
 571    TyCon_COLtycon (CollectionDesc x_COLtycon);
 572 };
 573
 574 ///////////////////////////////////////////////////////////////////////////////
 575 //
 576 // Class for datatype constructor TyCon::GRAPHtycon
 577 //
 578 ///////////////////////////////////////////////////////////////////////////////
 579 class TyCon_GRAPHtycon : public a_TyCon {
 580 public:
 581 #line 162 "ir.ph"
 582    GraphTypeDef * GRAPHtycon;
 583    TyCon_GRAPHtycon (GraphTypeDef * x_GRAPHtycon);
 584 };
 585
 586 ///////////////////////////////////////////////////////////////////////////////
 587 //
 588 // Class for datatype constructor TyCon::NODEtycon
 589 //
 590 ///////////////////////////////////////////////////////////////////////////////
 591 class TyCon_NODEtycon : public a_TyCon {
 592 public:
 593 #line 163 "ir.ph"
 594    NodeDef * NODEtycon;
 595    TyCon_NODEtycon (NodeDef * x_NODEtycon);
 596 };
 597
 598 ///////////////////////////////////////////////////////////////////////////////
 599 //
 600 // Class for datatype constructor TyCon::EDGEtycon
 601 //
 602 ///////////////////////////////////////////////////////////////////////////////
 603 class TyCon_EDGEtycon : public a_TyCon {
 604 public:
 605 #line 164 "ir.ph"
 606    EdgeDef * EDGEtycon;
 607    TyCon_EDGEtycon (EdgeDef * x_EDGEtycon);
 608 };
 609
 610 ///////////////////////////////////////////////////////////////////////////////
 611 //
 612 // Datatype constructor functions for TyCon
 613 //
 614 ///////////////////////////////////////////////////////////////////////////////
 615 extern a_TyCon * IDtycon (Id x_IDtycon);
 616 extern a_TyCon * RECORDtycon (a_List<Id> *  x_1, Bool x_2);
 617 extern a_TyCon * ARRAYtycon (Exp x_ARRAYtycon);
 618 extern a_TyCon * BITFIELDtycon (int x_width, Bool x_is_signed = false);
 619 extern 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 = 0);
 620 extern a_TyCon * COLtycon (CollectionDesc x_COLtycon);
 621 extern a_TyCon * GRAPHtycon (GraphTypeDef * x_GRAPHtycon);
 622 extern a_TyCon * NODEtycon (NodeDef * x_NODEtycon);
 623 extern a_TyCon * EDGEtycon (EdgeDef * x_EDGEtycon);
 624
 625 ///////////////////////////////////////////////////////////////////////////////
 626 //
 627 // Base class for datatype Pat
 628 //
 629 ///////////////////////////////////////////////////////////////////////////////
 630 class a_Pat : public MEM {
 631 public:
 632    enum Tag_Pat {
 633       tag_WILDpat = 0, tag_INDpat = 1, tag_POLYpat = 2,
 634       tag_IDpat = 3, tag_CONSpat = 4, tag_APPpat = 5,
 635       tag_TYPEDpat = 6, tag_ASpat = 7, tag_LITERALpat = 8,
 636       tag_CONTEXTpat = 9, tag_LEXEMEpat = 10, tag_ARRAYpat = 11,
 637       tag_TUPLEpat = 12, tag_EXTUPLEpat = 13, tag_RECORDpat = 14,
 638       tag_LISTpat = 15, tag_VECTORpat = 16, tag_APPENDpat = 17,
 639       tag_GUARDpat = 18, tag_LOGICALpat = 19, tag_BACKEDGEpat = 20,
 640       tag_UNIFYpat = 21, tag_MARKEDpat = 22
 641    };
 642
 643 public:
 644    const Tag_Pat tag__; // variant tag
 645 protected:
 646    inline a_Pat(Tag_Pat t__) : tag__(t__) {}
 647 public:
 648 #line 206 "ir.ph"
 649   Exp selector; Ty ty;
 650 #line 206 "ir.ph"
 651 };
 652 inline int boxed(const a_Pat * x) { return x != 0; }
 653 inline int untag(const a_Pat * x) { return x ? (x->tag__+1) : 0; }
 654 ///////////////////////////////////////////////////////////////////////////////
 655 //
 656 // Class for datatype constructor Pat::WILDpat
 657 //
 658 ///////////////////////////////////////////////////////////////////////////////
 659 class Pat_WILDpat : public a_Pat {
 660 public:
 661 #line 173 "ir.ph"
 662
 663    Pat_WILDpat ();
 664 };
 665
 666 ///////////////////////////////////////////////////////////////////////////////
 667 //
 668 // Class for datatype constructor Pat::INDpat
 669 //
 670 ///////////////////////////////////////////////////////////////////////////////
 671 class Pat_INDpat : public a_Pat {
 672 public:
 673 #line 174 "ir.ph"
 674    Id _1; int _2; Ty _3;
 675    Pat_INDpat (Id x_1, int x_2, Ty x_3);
 676 };
 677
 678 ///////////////////////////////////////////////////////////////////////////////
 679 //
 680 // Class for datatype constructor Pat::POLYpat
 681 //
 682 ///////////////////////////////////////////////////////////////////////////////
 683 class Pat_POLYpat : public a_Pat {
 684 public:
 685 #line 175 "ir.ph"
 686    Id _1; int _2; Ids _3; Pat _4; Exp _5; Bool _6;
 687    Pat_POLYpat (Id x_1, int x_2, Ids x_3, Pat x_4, Exp x_5, Bool x_6);
 688 };
 689
 690 ///////////////////////////////////////////////////////////////////////////////
 691 //
 692 // Class for datatype constructor Pat::IDpat
 693 //
 694 ///////////////////////////////////////////////////////////////////////////////
 695 class Pat_IDpat : public a_Pat {
 696 public:
 697 #line 176 "ir.ph"
 698    Id _1; Ty _2; Exp _3;
 699    Pat_IDpat (Id x_1, Ty x_2, Exp x_3);
 700 };
 701
 702 ///////////////////////////////////////////////////////////////////////////////
 703 //
 704 // Class for datatype constructor Pat::CONSpat
 705 //
 706 ///////////////////////////////////////////////////////////////////////////////
 707 class Pat_CONSpat : public a_Pat {
 708 public:
 709 #line 177 "ir.ph"
 710    Cons CONSpat;
 711    Pat_CONSpat (Cons x_CONSpat);
 712 };
 713
 714 ///////////////////////////////////////////////////////////////////////////////
 715 //
 716 // Class for datatype constructor Pat::APPpat
 717 //
 718 ///////////////////////////////////////////////////////////////////////////////
 719 class Pat_APPpat : public a_Pat {
 720 public:
 721 #line 178 "ir.ph"
 722    Pat _1; Pat _2;
 723    Pat_APPpat (Pat x_1, Pat x_2);
 724 };
 725
 726 ///////////////////////////////////////////////////////////////////////////////
 727 //
 728 // Class for datatype constructor Pat::TYPEDpat
 729 //
 730 ///////////////////////////////////////////////////////////////////////////////
 731 class Pat_TYPEDpat : public a_Pat {
 732 public:
 733 #line 179 "ir.ph"
 734    Pat _1; Ty _2;
 735    Pat_TYPEDpat (Pat x_1, Ty x_2);
 736 };
 737
 738 ///////////////////////////////////////////////////////////////////////////////
 739 //
 740 // Class for datatype constructor Pat::ASpat
 741 //
 742 ///////////////////////////////////////////////////////////////////////////////
 743 class Pat_ASpat : public a_Pat {
 744 public:
 745 #line 180 "ir.ph"
 746    Id _1; Pat _2; Ty _3; Exp _4;
 747    Pat_ASpat (Id x_1, Pat x_2, Ty x_3, Exp x_4);
 748 };
 749
 750 ///////////////////////////////////////////////////////////////////////////////
 751 //
 752 // Class for datatype constructor Pat::LITERALpat
 753 //
 754 ///////////////////////////////////////////////////////////////////////////////
 755 class Pat_LITERALpat : public a_Pat {
 756 public:
 757 #line 181 "ir.ph"
 758    Literal LITERALpat;
 759    Pat_LITERALpat (Literal x_LITERALpat);
 760 };
 761
 762 ///////////////////////////////////////////////////////////////////////////////
 763 //
 764 // Class for datatype constructor Pat::CONTEXTpat
 765 //
 766 ///////////////////////////////////////////////////////////////////////////////
 767 class Pat_CONTEXTpat : public a_Pat {
 768 public:
 769 #line 182 "ir.ph"
 770    Conses _1; Pat _2;
 771    Pat_CONTEXTpat (Conses x_1, Pat x_2);
 772 };
 773
 774 ///////////////////////////////////////////////////////////////////////////////
 775 //
 776 // Class for datatype constructor Pat::LEXEMEpat
 777 //
 778 ///////////////////////////////////////////////////////////////////////////////
 779 class Pat_LEXEMEpat : public a_Pat {
 780 public:
 781 #line 183 "ir.ph"
 782    Id _1; Ty _2; int _3; Cons * _4;
 783    Pat_LEXEMEpat (Id x_1, Ty x_2, int x_3, Cons * x_4);
 784 };
 785
 786 ///////////////////////////////////////////////////////////////////////////////
 787 //
 788 // Class for datatype constructor Pat::ARRAYpat
 789 //
 790 ///////////////////////////////////////////////////////////////////////////////
 791 class Pat_ARRAYpat : public a_Pat {
 792 public:
 793 #line 184 "ir.ph"
 794    a_List<Pat> *  _1; Bool _2;
 795    Pat_ARRAYpat (a_List<Pat> *  x_1, Bool x_2);
 796 };
 797
 798 ///////////////////////////////////////////////////////////////////////////////
 799 //
 800 // Class for datatype constructor Pat::TUPLEpat
 801 //
 802 ///////////////////////////////////////////////////////////////////////////////
 803 class Pat_TUPLEpat : public a_Pat {
 804 public:
 805 #line 185 "ir.ph"
 806    a_List<Pat> *  TUPLEpat;
 807    Pat_TUPLEpat (a_List<Pat> *  x_TUPLEpat);
 808 };
 809
 810 ///////////////////////////////////////////////////////////////////////////////
 811 //
 812 // Class for datatype constructor Pat::EXTUPLEpat
 813 //
 814 ///////////////////////////////////////////////////////////////////////////////
 815 class Pat_EXTUPLEpat : public a_Pat {
 816 public:
 817 #line 186 "ir.ph"
 818    a_List<Pat> *  EXTUPLEpat;
 819    Pat_EXTUPLEpat (a_List<Pat> *  x_EXTUPLEpat);
 820 };
 821
 822 ///////////////////////////////////////////////////////////////////////////////
 823 //
 824 // Class for datatype constructor Pat::RECORDpat
 825 //
 826 ///////////////////////////////////////////////////////////////////////////////
 827 class Pat_RECORDpat : public a_Pat {
 828 public:
 829 #line 187 "ir.ph"
 830    a_List<LabPat> *  _1; Bool _2;
 831    Pat_RECORDpat (a_List<LabPat> *  x_1, Bool x_2);
 832 };
 833
 834 ///////////////////////////////////////////////////////////////////////////////
 835 //
 836 // Class for datatype constructor Pat::LISTpat
 837 //
 838 ///////////////////////////////////////////////////////////////////////////////
 839 class Pat_LISTpat : public a_Pat {
 840 public:
 841 #line 188 "ir.ph"
 842    Cons cons; Cons nil; a_List<Pat> *  head; Pat tail;
 843    Pat_LISTpat (Cons x_cons, Cons x_nil, a_List<Pat> *  x_head, Pat x_tail);
 844 };
 845
 846 ///////////////////////////////////////////////////////////////////////////////
 847 //
 848 // Class for datatype constructor Pat::VECTORpat
 849 //
 850 ///////////////////////////////////////////////////////////////////////////////
 851 class Pat_VECTORpat : public a_Pat {
 852 public:
 853 #line 193 "ir.ph"
 854    Cons cons; Pat len; Pat array; a_List<Pat> *  elements; Bool head_flex; Bool tail_flex;
 855    Pat_VECTORpat (Cons x_cons, Pat x_len, Pat x_array, a_List<Pat> *  x_elements, Bool x_head_flex, Bool x_tail_flex);
 856 };
 857
 858 ///////////////////////////////////////////////////////////////////////////////
 859 //
 860 // Class for datatype constructor Pat::APPENDpat
 861 //
 862 ///////////////////////////////////////////////////////////////////////////////
 863 class Pat_APPENDpat : public a_Pat {
 864 public:
 865 #line 200 "ir.ph"
 866    Pat _1; Pat _2; Ty _3;
 867    Pat_APPENDpat (Pat x_1, Pat x_2, Ty x_3);
 868 };
 869
 870 ///////////////////////////////////////////////////////////////////////////////
 871 //
 872 // Class for datatype constructor Pat::GUARDpat
 873 //
 874 ///////////////////////////////////////////////////////////////////////////////
 875 class Pat_GUARDpat : public a_Pat {
 876 public:
 877 #line 201 "ir.ph"
 878    Pat _1; Exp _2;
 879    Pat_GUARDpat (Pat x_1, Exp x_2);
 880 };
 881
 882 ///////////////////////////////////////////////////////////////////////////////
 883 //
 884 // Class for datatype constructor Pat::LOGICALpat
 885 //
 886 ///////////////////////////////////////////////////////////////////////////////
 887 class Pat_LOGICALpat : public a_Pat {
 888 public:
 889 #line 202 "ir.ph"
 890    LogicalPat _1; Pat _2; Pat _3;
 891    Pat_LOGICALpat (LogicalPat x_1, Pat x_2, Pat x_3 = NOpat);
 892 };
 893
 894 ///////////////////////////////////////////////////////////////////////////////
 895 //
 896 // Class for datatype constructor Pat::BACKEDGEpat
 897 //
 898 ///////////////////////////////////////////////////////////////////////////////
 899 class Pat_BACKEDGEpat : public a_Pat {
 900 public:
 901 #line 203 "ir.ph"
 902    int _1; Id _2; Pat _3;
 903    Pat_BACKEDGEpat (int x_1, Id x_2, Pat x_3);
 904 };
 905
 906 ///////////////////////////////////////////////////////////////////////////////
 907 //
 908 // Class for datatype constructor Pat::UNIFYpat
 909 //
 910 ///////////////////////////////////////////////////////////////////////////////
 911 class Pat_UNIFYpat : public a_Pat {
 912 public:
 913 #line 204 "ir.ph"
 914    Pat _1; Exp _2;
 915    Pat_UNIFYpat (Pat x_1, Exp x_2);
 916 };
 917
 918 ///////////////////////////////////////////////////////////////////////////////
 919 //
 920 // Class for datatype constructor Pat::MARKEDpat
 921 //
 922 ///////////////////////////////////////////////////////////////////////////////
 923 class Pat_MARKEDpat : public a_Pat {
 924 public:
 925 #line 205 "ir.ph"
 926    Loc _1; Pat _2;
 927    Pat_MARKEDpat (Loc x_1, Pat x_2);
 928 };
 929
 930 ///////////////////////////////////////////////////////////////////////////////
 931 //
 932 // Datatype constructor functions for Pat
 933 //
 934 ///////////////////////////////////////////////////////////////////////////////
 935 extern a_Pat * WILDpat ();
 936 extern a_Pat * INDpat (Id x_1, int x_2, Ty x_3);
 937 extern a_Pat * POLYpat (Id x_1, int x_2, Ids x_3, Pat x_4, Exp x_5, Bool x_6);
 938 extern a_Pat * IDpat (Id x_1, Ty x_2, Exp x_3);
 939 extern a_Pat * CONSpat (Cons x_CONSpat);
 940 extern a_Pat * APPpat (Pat x_1, Pat x_2);
 941 extern a_Pat * TYPEDpat (Pat x_1, Ty x_2);
 942 extern a_Pat * ASpat (Id x_1, Pat x_2, Ty x_3, Exp x_4);
 943 extern a_Pat * LITERALpat (Literal x_LITERALpat);
 944 extern a_Pat * CONTEXTpat (Conses x_1, Pat x_2);
 945 extern a_Pat * LEXEMEpat (Id x_1, Ty x_2, int x_3, Cons * x_4);
 946 extern a_Pat * ARRAYpat (a_List<Pat> *  x_1, Bool x_2);
 947 extern a_Pat * TUPLEpat (a_List<Pat> *  x_TUPLEpat);
 948 extern a_Pat * EXTUPLEpat (a_List<Pat> *  x_EXTUPLEpat);
 949 extern a_Pat * RECORDpat (a_List<LabPat> *  x_1, Bool x_2);
 950 extern a_Pat * LISTpat (Cons x_cons, Cons x_nil, a_List<Pat> *  x_head, Pat x_tail);
 951 extern 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);
 952 extern a_Pat * APPENDpat (Pat x_1, Pat x_2, Ty x_3);
 953 extern a_Pat * GUARDpat (Pat x_1, Exp x_2);
 954 extern a_Pat * LOGICALpat (LogicalPat x_1, Pat x_2, Pat x_3 = NOpat);
 955 extern a_Pat * BACKEDGEpat (int x_1, Id x_2, Pat x_3);
 956 extern a_Pat * UNIFYpat (Pat x_1, Exp x_2);
 957 extern a_Pat * MARKEDpat (Loc x_1, Pat x_2);
 958
 959
 960 ///////////////////////////////////////////////////////////////////////////////
 961 //
 962 // Base class for datatype Literal
 963 //
 964 ///////////////////////////////////////////////////////////////////////////////
 965 class a_Literal : public MEM {
 966 public:
 967    enum Tag_Literal {
 968       tag_INTlit = 0, tag_BOOLlit = 1, tag_CHARlit = 2,
 969       tag_REALlit = 3, tag_STRINGlit = 4, tag_REGEXPlit = 5,
 970       tag_QUARKlit = 6, tag_BIGINTlit = 7
 971    };
 972
 973 public:
 974    const Tag_Literal tag__; // variant tag
 975 protected:
 976    inline a_Literal(Tag_Literal t__) : tag__(t__) {}
 977 public:
 978 };
 979 inline int boxed(const a_Literal *) { return 1; }
 980 inline int untag(const a_Literal * x) { return x->tag__; }
 981 ///////////////////////////////////////////////////////////////////////////////
 982 //
 983 // Class for datatype constructor Literal::INTlit
 984 //
 985 ///////////////////////////////////////////////////////////////////////////////
 986 class Literal_INTlit : public a_Literal {
 987 public:
 988 #line 228 "ir.ph"
 989    int INTlit;
 990    Literal_INTlit (int x_INTlit);
 991 };
 992
 993 ///////////////////////////////////////////////////////////////////////////////
 994 //
 995 // Class for datatype constructor Literal::BOOLlit
 996 //
 997 ///////////////////////////////////////////////////////////////////////////////
 998 class Literal_BOOLlit : public a_Literal {
 999 public:
1000 #line 229 "ir.ph"
1001    Bool BOOLlit;
1002    Literal_BOOLlit (Bool x_BOOLlit);
1003 };
1004
1005 ///////////////////////////////////////////////////////////////////////////////
1006 //
1007 // Class for datatype constructor Literal::CHARlit
1008 //
1009 ///////////////////////////////////////////////////////////////////////////////
1010 class Literal_CHARlit : public a_Literal {
1011 public:
1012 #line 230 "ir.ph"
1013    char CHARlit;
1014    Literal_CHARlit (char x_CHARlit);
1015 };
1016
1017 ///////////////////////////////////////////////////////////////////////////////
1018 //
1019 // Class for datatype constructor Literal::REALlit
1020 //
1021 ///////////////////////////////////////////////////////////////////////////////
1022 class Literal_REALlit : public a_Literal {
1023 public:
1024 #line 231 "ir.ph"
1025    double REALlit;
1026    Literal_REALlit (double x_REALlit);
1027 };
1028
1029 ///////////////////////////////////////////////////////////////////////////////
1030 //
1031 // Class for datatype constructor Literal::STRINGlit
1032 //
1033 ///////////////////////////////////////////////////////////////////////////////
1034 class Literal_STRINGlit : public a_Literal {
1035 public:
1036 #line 232 "ir.ph"
1037    char const * STRINGlit;
1038    Literal_STRINGlit (char const * x_STRINGlit);
1039 };
1040
1041 ///////////////////////////////////////////////////////////////////////////////
1042 //
1043 // Class for datatype constructor Literal::REGEXPlit
1044 //
1045 ///////////////////////////////////////////////////////////////////////////////
1046 class Literal_REGEXPlit : public a_Literal {
1047 public:
1048 #line 233 "ir.ph"
1049    char const * REGEXPlit;
1050    Literal_REGEXPlit (char const * x_REGEXPlit);
1051 };
1052
1053 ///////////////////////////////////////////////////////////////////////////////
1054 //
1055 // Class for datatype constructor Literal::QUARKlit
1056 //
1057 ///////////////////////////////////////////////////////////////////////////////
1058 class Literal_QUARKlit : public a_Literal {
1059 public:
1060 #line 234 "ir.ph"
1061    char const * QUARKlit;
1062    Literal_QUARKlit (char const * x_QUARKlit);
1063 };
1064
1065 ///////////////////////////////////////////////////////////////////////////////
1066 //
1067 // Class for datatype constructor Literal::BIGINTlit
1068 //
1069 ///////////////////////////////////////////////////////////////////////////////
1070 class Literal_BIGINTlit : public a_Literal {
1071 public:
1072 #line 235 "ir.ph"
1073    char const * BIGINTlit;
1074    Literal_BIGINTlit (char const * x_BIGINTlit);
1075 };
1076
1077 ///////////////////////////////////////////////////////////////////////////////
1078 //
1079 // Datatype constructor functions for Literal
1080 //
1081 ///////////////////////////////////////////////////////////////////////////////
1082 extern a_Literal * INTlit (int x_INTlit);
1083 extern a_Literal * BOOLlit (Bool x_BOOLlit);
1084 extern a_Literal * CHARlit (char x_CHARlit);
1085 extern a_Literal * REALlit (double x_REALlit);
1086 extern a_Literal * STRINGlit (char const * x_STRINGlit);
1087 extern a_Literal * REGEXPlit (char const * x_REGEXPlit);
1088 extern a_Literal * QUARKlit (char const * x_QUARKlit);
1089 extern a_Literal * BIGINTlit (char const * x_BIGINTlit);
1090
1091 ///////////////////////////////////////////////////////////////////////////////
1092 //
1093 // Class for datatype constructor Cons::ONEcons
1094 //
1095 ///////////////////////////////////////////////////////////////////////////////
1096 class a_Cons : public MEM {
1097 public:
1098 #line 244 "ir.ph"
1099    Id name; Ty alg_ty; Ty cons_ty; Ty ty; int tag; PrintFormats print_formats; Loc const * location; a_List<Inherit> *  inherit; a_List<Decl> *  body; TyOpt opt; TyQual qual; Exp view_predicate; Exp * view_selectors; Pat lexeme_pattern; DatatypeClass * class_def;
1100    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 = 0);
1101 };
1102 inline int boxed(const a_Cons * x) { return x != 0; }
1103 inline int untag(const a_Cons * x) { return x ? 1 : 0; }
1104 ///////////////////////////////////////////////////////////////////////////////
1105 //
1106 // Datatype constructor functions for Cons
1107 //
1108 ///////////////////////////////////////////////////////////////////////////////
1109 extern 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 = 0);
1110
1111 ///////////////////////////////////////////////////////////////////////////////
1112 //
1113 // Base class for datatype ProductionSymbol
1114 //
1115 ///////////////////////////////////////////////////////////////////////////////
1116 class a_ProductionSymbol : public Loc {
1117 public:
1118    enum Tag_ProductionSymbol {
1119       tag_TERMsym = 0, tag_TERMSTRINGsym = 1, tag_TERMREGEXPsym = 2,
1120       tag_TOKENsym = 3, tag_NONTERMsym = 4, tag_POSNONTERMsym = 5,
1121       tag_ACTIONsym = 6, tag_PREDICATEsym = 7, tag_PRECsym = 8,
1122       tag_ERRORsym = 9, tag_SPECIALsym = 10
1123    };
1124
1125 public:
1126    const Tag_ProductionSymbol tag__; // variant tag
1127 protected:
1128    inline a_ProductionSymbol(Tag_ProductionSymbol t__) : tag__(t__) {}
1129 public:
1130 };
1131 inline int boxed(const a_ProductionSymbol *) { return 1; }
1132 inline int untag(const a_ProductionSymbol * x) { return x->tag__; }
1133 ///////////////////////////////////////////////////////////////////////////////
1134 //
1135 // Class for datatype constructor ProductionSymbol::TERMsym
1136 //
1137 ///////////////////////////////////////////////////////////////////////////////
1138 class ProductionSymbol_TERMsym : public a_ProductionSymbol {
1139 public:
1140 #line 268 "ir.ph"
1141    char TERMsym;
1142    ProductionSymbol_TERMsym (char x_TERMsym);
1143 };
1144
1145 ///////////////////////////////////////////////////////////////////////////////
1146 //
1147 // Class for datatype constructor ProductionSymbol::TERMSTRINGsym
1148 //
1149 ///////////////////////////////////////////////////////////////////////////////
1150 class ProductionSymbol_TERMSTRINGsym : public a_ProductionSymbol {
1151 public:
1152 #line 269 "ir.ph"
1153    char const * TERMSTRINGsym;
1154    ProductionSymbol_TERMSTRINGsym (char const * x_TERMSTRINGsym);
1155 };
1156
1157 ///////////////////////////////////////////////////////////////////////////////
1158 //
1159 // Class for datatype constructor ProductionSymbol::TERMREGEXPsym
1160 //
1161 ///////////////////////////////////////////////////////////////////////////////
1162 class ProductionSymbol_TERMREGEXPsym : public a_ProductionSymbol {
1163 public:
1164 #line 270 "ir.ph"
1165    char const * TERMREGEXPsym;
1166    ProductionSymbol_TERMREGEXPsym (char const * x_TERMREGEXPsym);
1167 };
1168
1169 ///////////////////////////////////////////////////////////////////////////////
1170 //
1171 // Class for datatype constructor ProductionSymbol::TOKENsym
1172 //
1173 ///////////////////////////////////////////////////////////////////////////////
1174 class ProductionSymbol_TOKENsym : public a_ProductionSymbol {
1175 public:
1176 #line 271 "ir.ph"
1177    Cons TOKENsym;
1178    ProductionSymbol_TOKENsym (Cons x_TOKENsym);
1179 };
1180
1181 ///////////////////////////////////////////////////////////////////////////////
1182 //
1183 // Class for datatype constructor ProductionSymbol::NONTERMsym
1184 //
1185 ///////////////////////////////////////////////////////////////////////////////
1186 class ProductionSymbol_NONTERMsym : public a_ProductionSymbol {
1187 public:
1188 #line 272 "ir.ph"
1189    Id NONTERMsym;
1190    ProductionSymbol_NONTERMsym (Id x_NONTERMsym);
1191 };
1192
1193 ///////////////////////////////////////////////////////////////////////////////
1194 //
1195 // Class for datatype constructor ProductionSymbol::POSNONTERMsym
1196 //
1197 ///////////////////////////////////////////////////////////////////////////////
1198 class ProductionSymbol_POSNONTERMsym : public a_ProductionSymbol {
1199 public:
1200 #line 273 "ir.ph"
1201    int POSNONTERMsym;
1202    ProductionSymbol_POSNONTERMsym (int x_POSNONTERMsym);
1203 };
1204
1205 ///////////////////////////////////////////////////////////////////////////////
1206 //
1207 // Class for datatype constructor ProductionSymbol::ACTIONsym
1208 //
1209 ///////////////////////////////////////////////////////////////////////////////
1210 class ProductionSymbol_ACTIONsym : public a_ProductionSymbol {
1211 public:
1212 #line 274 "ir.ph"
1213    a_List<Decl> *  ACTIONsym;
1214    ProductionSymbol_ACTIONsym (a_List<Decl> *  x_ACTIONsym);
1215 };
1216
1217 ///////////////////////////////////////////////////////////////////////////////
1218 //
1219 // Class for datatype constructor ProductionSymbol::PREDICATEsym
1220 //
1221 ///////////////////////////////////////////////////////////////////////////////
1222 class ProductionSymbol_PREDICATEsym : public a_ProductionSymbol {
1223 public:
1224 #line 275 "ir.ph"
1225    Exp PREDICATEsym;
1226    ProductionSymbol_PREDICATEsym (Exp x_PREDICATEsym);
1227 };
1228
1229 ///////////////////////////////////////////////////////////////////////////////
1230 //
1231 // Class for datatype constructor ProductionSymbol::PRECsym
1232 //
1233 ///////////////////////////////////////////////////////////////////////////////
1234 class ProductionSymbol_PRECsym : public a_ProductionSymbol {
1235 public:
1236 #line 276 "ir.ph"
1237    Cons PRECsym;
1238    ProductionSymbol_PRECsym (Cons x_PRECsym);
1239 };
1240
1241 ///////////////////////////////////////////////////////////////////////////////
1242 //
1243 // Class for datatype constructor ProductionSymbol::ERRORsym
1244 //
1245 ///////////////////////////////////////////////////////////////////////////////
1246 class ProductionSymbol_ERRORsym : public a_ProductionSymbol {
1247 public:
1248 #line 277 "ir.ph"
1249
1250    ProductionSymbol_ERRORsym ();
1251 };
1252
1253 ///////////////////////////////////////////////////////////////////////////////
1254 //
1255 // Class for datatype constructor ProductionSymbol::SPECIALsym
1256 //
1257 ///////////////////////////////////////////////////////////////////////////////
1258 class ProductionSymbol_SPECIALsym : public a_ProductionSymbol {
1259 public:
1260 #line 278 "ir.ph"
1261    char SPECIALsym;
1262    ProductionSymbol_SPECIALsym (char x_SPECIALsym);
1263 };
1264
1265 ///////////////////////////////////////////////////////////////////////////////
1266 //
1267 // Datatype constructor functions for ProductionSymbol
1268 //
1269 ///////////////////////////////////////////////////////////////////////////////
1270 extern a_ProductionSymbol * TERMsym (char x_TERMsym);
1271 extern a_ProductionSymbol * TERMSTRINGsym (char const * x_TERMSTRINGsym);
1272 extern a_ProductionSymbol * TERMREGEXPsym (char const * x_TERMREGEXPsym);
1273 extern a_ProductionSymbol * TOKENsym (Cons x_TOKENsym);
1274 extern a_ProductionSymbol * NONTERMsym (Id x_NONTERMsym);
1275 extern a_ProductionSymbol * POSNONTERMsym (int x_POSNONTERMsym);
1276 extern a_ProductionSymbol * ACTIONsym (a_List<Decl> *  x_ACTIONsym);
1277 extern a_ProductionSymbol * PREDICATEsym (Exp x_PREDICATEsym);
1278 extern a_ProductionSymbol * PRECsym (Cons x_PRECsym);
1279 extern a_ProductionSymbol * ERRORsym ();
1280 extern a_ProductionSymbol * SPECIALsym (char x_SPECIALsym);
1281
1282 ///////////////////////////////////////////////////////////////////////////////
1283 //
1284 // Class for datatype constructor Pid::PERSISTid
1285 //
1286 ///////////////////////////////////////////////////////////////////////////////
1287 class a_Pid : public MEM {
1288 public:
1289 #line 285 "ir.ph"
1290    char const * PERSISTid;
1291    a_Pid (char const * x_PERSISTid);
1292 };
1293 inline int boxed(const a_Pid * x) { return x != 0; }
1294 inline int untag(const a_Pid * x) { return x ? 1 : 0; }
1295 ///////////////////////////////////////////////////////////////////////////////
1296 //
1297 // Datatype constructor functions for Pid
1298 //
1299 ///////////////////////////////////////////////////////////////////////////////
1300 extern a_Pid * PERSISTid (char const * x_PERSISTid);
1301
1302 ///////////////////////////////////////////////////////////////////////////////
1303 //
1304 // Class for datatype constructor Inherit::INHERIT
1305 //
1306 ///////////////////////////////////////////////////////////////////////////////
1307 class a_Inherit : public Loc {
1308 public:
1309 #line 292 "ir.ph"
1310    Ty super_class; Scope scope; TyQual qualifiers;
1311    a_Inherit (Ty x_super_class, Scope x_scope = PUBLICscope, TyQual x_qualifiers = QUALnone);
1312 };
1313 inline int boxed(const a_Inherit *) { return 1; }
1314 inline int untag(const a_Inherit *) { return 0; }
1315 ///////////////////////////////////////////////////////////////////////////////
1316 //
1317 // Datatype constructor functions for Inherit
1318 //
1319 ///////////////////////////////////////////////////////////////////////////////
1320 extern a_Inherit * INHERIT (Ty x_super_class, Scope x_scope = PUBLICscope, TyQual x_qualifiers = QUALnone);
1321
1322 #line 346 "ir.ph"
1323 #line 346 "ir.ph"
1324
1325
1326 ///////////////////////////////////////////////////////////////////////////////
1327 //
1328 //  Pretty printing methods
1329 //
1330 ///////////////////////////////////////////////////////////////////////////////
1331 extern std::ostream& operator << (std::ostream&, Ids);
1332 extern std::ostream& operator << (std::ostream&, Scope);
1333 extern std::ostream& operator << (std::ostream&, Ty);
1334 extern std::ostream& operator << (std::ostream&,
1335 #line 356 "ir.ph"
1336 a_List<Ty> *
1337 #line 356 "ir.ph"
1338 );
1339 extern std::ostream& operator << (std::ostream&, Pat);
1340 extern std::ostream& operator << (std::ostream&, LabPat);
1341 extern std::ostream& operator << (std::ostream&, a_List<Pat> *
1342 #line 359 "ir.ph"
1343 );
1344 extern std::ostream& operator << (std::ostream&, a_List<LabPat> *
1345 #line 360 "ir.ph"
1346 );
1347 extern std::ostream& operator << (std::ostream&, Literal);
1348 extern std::ostream& operator << (std::ostream&, Inherit);
1349 extern std::ostream& operator << (std::ostream&, a_List<Inherit> *
1350 #line 363 "ir.ph"
1351 );
1352 extern std::ostream& operator << (std::ostream&, Pid);
1353 extern std::ostream& print_cons (std::ostream&, Cons);
1354 extern void     print_parameter (std::ostream&, Ty, Id, Parameter);
1355 extern void     print_tyvars    (std::ostream&, TyVars, char, char, Bool);
1356 extern Id       index_of (int, Id = 0);
1357
1358 #endif
1359 /*
1360 ------------------------------- Statistics -------------------------------
1361 Merge matching rules         = yes
1362 Number of DFA nodes merged   = 0
1363 Number of ifs generated      = 0
1364 Number of switches generated = 0
1365 Number of labels             = 0
1366 Number of gotos              = 0
1367 Adaptive matching            = enabled
1368 Fast string matching         = disabled
1369 Inline downcasts             = enabled
1370 --------------------------------------------------------------------------
1371 */