app/setl-pe/setl-ast.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //  This file is generated automatically using Prop (version 2.3.2),
   3 //  last updated on Mar 14, 1997.
   4 //  The original source file is "setl-ast.ph".
   5 ///////////////////////////////////////////////////////////////////////////////
   6
   7 #define PROP_GARBAGE_COLLECTION_USED
   8 #define PROP_PRINTER_USED
   9 #include <propdefs.h>
  10 #line 1 "setl-ast.ph"
  11 #ifndef SETL_abstract_syntax_h
  12 #define SETL_abstract_syntax_h
  13
  14 #include "foundation.h"
  15
  16 #line 6 "setl-ast.ph"
  17 #line 51 "setl-ast.ph"
  18 ///////////////////////////////////////////////////////////////////////////////
  19 //
  20 // Forward class definition for Exp
  21 //
  22 ///////////////////////////////////////////////////////////////////////////////
  23 #ifndef datatype_Exp_defined
  24 #define datatype_Exp_defined
  25    class a_Exp;
  26    typedef a_Exp * Exp;
  27 #endif
  28
  29 enum Prim {
  30    XXclXX = 0, XXcnXX = 1, XXckXX = 2,
  31    XXcpXX = 3, XXdkdnXX = 4, XXdnXX = 5,
  32    XXdmXX = 6, XXdoXX = 7, XXdodnXX = 8,
  33    XXdmdnXX = 9, XXcpdnXX = 10, XXcdXX = 11,
  34    XX_a_r_bXX = 12, XX_d_i_vXX = 13, XX_m_o_dXX = 14,
  35    XX_w_i_t_hXX = 15, XX_l_e_s_sXX = 16
  36 };
  37
  38
  39
  40 ///////////////////////////////////////////////////////////////////////////////
  41 //
  42 // Forward class definition for Decl
  43 //
  44 ///////////////////////////////////////////////////////////////////////////////
  45 #ifndef datatype_Decl_defined
  46 #define datatype_Decl_defined
  47    class a_Decl;
  48    typedef a_Decl * Decl;
  49 #endif
  50
  51 ///////////////////////////////////////////////////////////////////////////////
  52 //
  53 // Forward class definition for Term
  54 //
  55 ///////////////////////////////////////////////////////////////////////////////
  56 #ifndef datatype_Term_defined
  57 #define datatype_Term_defined
  58    class a_Term;
  59    typedef a_Term * Term;
  60 #endif
  61
  62 ///////////////////////////////////////////////////////////////////////////////
  63 //
  64 // Forward class definition for Ty
  65 //
  66 ///////////////////////////////////////////////////////////////////////////////
  67 #ifndef datatype_Ty_defined
  68 #define datatype_Ty_defined
  69    class a_Ty;
  70    typedef a_Ty * Ty;
  71 #endif
  72
  73 #  define NOty (Ty)0
  74
  75 ///////////////////////////////////////////////////////////////////////////////
  76 //
  77 // Forward class definition for LabeledExp
  78 //
  79 ///////////////////////////////////////////////////////////////////////////////
  80 #ifndef datatype_LabeledExp_defined
  81 #define datatype_LabeledExp_defined
  82    class a_LabeledExp;
  83    typedef a_LabeledExp * LabeledExp;
  84 #endif
  85
  86 ///////////////////////////////////////////////////////////////////////////////
  87 //
  88 // Forward class definition for Literal
  89 //
  90 ///////////////////////////////////////////////////////////////////////////////
  91 #ifndef datatype_Literal_defined
  92 #define datatype_Literal_defined
  93    class a_Literal;
  94    typedef a_Literal * Literal;
  95 #endif
  96
  97 ///////////////////////////////////////////////////////////////////////////////
  98 // Definition of type Ids
  99 ///////////////////////////////////////////////////////////////////////////////
 100 #line 44 "setl-ast.ph"
 101 typedef a_List<Id> *  Ids;
 102
 103 ///////////////////////////////////////////////////////////////////////////////
 104 // Definition of type Literals
 105 ///////////////////////////////////////////////////////////////////////////////
 106 #line 45 "setl-ast.ph"
 107 typedef a_List<Literal> *  Literals;
 108
 109 ///////////////////////////////////////////////////////////////////////////////
 110 // Definition of type Exps
 111 ///////////////////////////////////////////////////////////////////////////////
 112 #line 46 "setl-ast.ph"
 113 typedef a_List<Exp> *  Exps;
 114
 115 ///////////////////////////////////////////////////////////////////////////////
 116 // Definition of type LabeledExps
 117 ///////////////////////////////////////////////////////////////////////////////
 118 #line 47 "setl-ast.ph"
 119 typedef a_List<LabeledExp> *  LabeledExps;
 120
 121 ///////////////////////////////////////////////////////////////////////////////
 122 // Definition of type Decls
 123 ///////////////////////////////////////////////////////////////////////////////
 124 #line 48 "setl-ast.ph"
 125 typedef a_List<Decl> *  Decls;
 126
 127 ///////////////////////////////////////////////////////////////////////////////
 128 // Definition of type Terms
 129 ///////////////////////////////////////////////////////////////////////////////
 130 #line 49 "setl-ast.ph"
 131 typedef a_List<Term> *  Terms;
 132
 133 ///////////////////////////////////////////////////////////////////////////////
 134 // Definition of type Tys
 135 ///////////////////////////////////////////////////////////////////////////////
 136 #line 50 "setl-ast.ph"
 137 typedef a_List<Ty> *  Tys;
 138
 139 ///////////////////////////////////////////////////////////////////////////////
 140 //
 141 // Base class for datatype Exp
 142 //
 143 ///////////////////////////////////////////////////////////////////////////////
 144 class a_Exp : public GCObject {
 145 public:
 146    enum Tag_Exp {
 147       tag_IDexp = 0, tag_LITexp = 1, tag_APPexp = 2,
 148       tag_TUPLEexp = 3, tag_RECORDexp = 4, tag_SETexp = 5,
 149       tag_CASEexp = 6, tag_IFexp = 7, tag_WHILEexp = 8,
 150       tag_SEQexp = 9, tag_LETexp = 10, tag_PRIMexp = 11
 151    };
 152
 153 public:
 154    const Tag_Exp tag__; // variant tag
 155 protected:
 156    inline a_Exp(Tag_Exp t__) : tag__(t__) {}
 157 public:
 158    virtual ~a_Exp();
 159    ////////////////////////////////////////////////////////////////////////////
 160    //
 161    // Method for garbage collection tracing
 162    //
 163    ////////////////////////////////////////////////////////////////////////////
 164 protected:
 165    virtual void trace(GC *);
 166 public:
 167 };
 168 inline int boxed(const a_Exp *) { return 1; }
 169 inline int untag(const a_Exp * x) { return x->tag__; }
 170 ///////////////////////////////////////////////////////////////////////////////
 171 //
 172 // Class for datatype constructor Exp::IDexp
 173 //
 174 ///////////////////////////////////////////////////////////////////////////////
 175 class Exp_IDexp : public a_Exp {
 176 public:
 177 #line 6 "setl-ast.ph"
 178    Id IDexp;
 179    Exp_IDexp (Id x_IDexp);
 180    ~Exp_IDexp();
 181    ////////////////////////////////////////////////////////////////////////////
 182    //
 183    // Method for garbage collection tracing
 184    //
 185    ////////////////////////////////////////////////////////////////////////////
 186 protected:
 187    virtual void trace(GC *);
 188 public:
 189 };
 190
 191 ///////////////////////////////////////////////////////////////////////////////
 192 //
 193 // Class for datatype constructor Exp::LITexp
 194 //
 195 ///////////////////////////////////////////////////////////////////////////////
 196 class Exp_LITexp : public a_Exp {
 197 public:
 198 #line 8 "setl-ast.ph"
 199    Literal LITexp;
 200    Exp_LITexp (Literal x_LITexp);
 201    ~Exp_LITexp();
 202    ////////////////////////////////////////////////////////////////////////////
 203    //
 204    // Method for garbage collection tracing
 205    //
 206    ////////////////////////////////////////////////////////////////////////////
 207 protected:
 208    virtual void trace(GC *);
 209 public:
 210 };
 211
 212 ///////////////////////////////////////////////////////////////////////////////
 213 //
 214 // Class for datatype constructor Exp::APPexp
 215 //
 216 ///////////////////////////////////////////////////////////////////////////////
 217 class Exp_APPexp : public a_Exp {
 218 public:
 219 #line 9 "setl-ast.ph"
 220    Exp _1; Exp _2;
 221    Exp_APPexp (Exp x_1, Exp x_2);
 222    ~Exp_APPexp();
 223    ////////////////////////////////////////////////////////////////////////////
 224    //
 225    // Method for garbage collection tracing
 226    //
 227    ////////////////////////////////////////////////////////////////////////////
 228 protected:
 229    virtual void trace(GC *);
 230 public:
 231 };
 232
 233 ///////////////////////////////////////////////////////////////////////////////
 234 //
 235 // Class for datatype constructor Exp::TUPLEexp
 236 //
 237 ///////////////////////////////////////////////////////////////////////////////
 238 class Exp_TUPLEexp : public a_Exp {
 239 public:
 240 #line 10 "setl-ast.ph"
 241    Exps TUPLEexp;
 242    Exp_TUPLEexp (Exps x_TUPLEexp);
 243    ~Exp_TUPLEexp();
 244    ////////////////////////////////////////////////////////////////////////////
 245    //
 246    // Method for garbage collection tracing
 247    //
 248    ////////////////////////////////////////////////////////////////////////////
 249 protected:
 250    virtual void trace(GC *);
 251 public:
 252 };
 253
 254 ///////////////////////////////////////////////////////////////////////////////
 255 //
 256 // Class for datatype constructor Exp::RECORDexp
 257 //
 258 ///////////////////////////////////////////////////////////////////////////////
 259 class Exp_RECORDexp : public a_Exp {
 260 public:
 261 #line 11 "setl-ast.ph"
 262    LabeledExps RECORDexp;
 263    Exp_RECORDexp (LabeledExps x_RECORDexp);
 264    ~Exp_RECORDexp();
 265    ////////////////////////////////////////////////////////////////////////////
 266    //
 267    // Method for garbage collection tracing
 268    //
 269    ////////////////////////////////////////////////////////////////////////////
 270 protected:
 271    virtual void trace(GC *);
 272 public:
 273 };
 274
 275 ///////////////////////////////////////////////////////////////////////////////
 276 //
 277 // Class for datatype constructor Exp::SETexp
 278 //
 279 ///////////////////////////////////////////////////////////////////////////////
 280 class Exp_SETexp : public a_Exp {
 281 public:
 282 #line 12 "setl-ast.ph"
 283    Exps SETexp;
 284    Exp_SETexp (Exps x_SETexp);
 285    ~Exp_SETexp();
 286    ////////////////////////////////////////////////////////////////////////////
 287    //
 288    // Method for garbage collection tracing
 289    //
 290    ////////////////////////////////////////////////////////////////////////////
 291 protected:
 292    virtual void trace(GC *);
 293 public:
 294 };
 295
 296 ///////////////////////////////////////////////////////////////////////////////
 297 //
 298 // Class for datatype constructor Exp::CASEexp
 299 //
 300 ///////////////////////////////////////////////////////////////////////////////
 301 class Exp_CASEexp : public a_Exp {
 302 public:
 303 #line 13 "setl-ast.ph"
 304    Exp _1; Exps _2;
 305    Exp_CASEexp (Exp x_1, Exps x_2);
 306    ~Exp_CASEexp();
 307    ////////////////////////////////////////////////////////////////////////////
 308    //
 309    // Method for garbage collection tracing
 310    //
 311    ////////////////////////////////////////////////////////////////////////////
 312 protected:
 313    virtual void trace(GC *);
 314 public:
 315 };
 316
 317 ///////////////////////////////////////////////////////////////////////////////
 318 //
 319 // Class for datatype constructor Exp::IFexp
 320 //
 321 ///////////////////////////////////////////////////////////////////////////////
 322 class Exp_IFexp : public a_Exp {
 323 public:
 324 #line 14 "setl-ast.ph"
 325    Exp _1; Exp _2; Exp _3;
 326    Exp_IFexp (Exp x_1, Exp x_2, Exp x_3);
 327    ~Exp_IFexp();
 328    ////////////////////////////////////////////////////////////////////////////
 329    //
 330    // Method for garbage collection tracing
 331    //
 332    ////////////////////////////////////////////////////////////////////////////
 333 protected:
 334    virtual void trace(GC *);
 335 public:
 336 };
 337
 338 ///////////////////////////////////////////////////////////////////////////////
 339 //
 340 // Class for datatype constructor Exp::WHILEexp
 341 //
 342 ///////////////////////////////////////////////////////////////////////////////
 343 class Exp_WHILEexp : public a_Exp {
 344 public:
 345 #line 15 "setl-ast.ph"
 346    Exp _1; Exp _2;
 347    Exp_WHILEexp (Exp x_1, Exp x_2);
 348    ~Exp_WHILEexp();
 349    ////////////////////////////////////////////////////////////////////////////
 350    //
 351    // Method for garbage collection tracing
 352    //
 353    ////////////////////////////////////////////////////////////////////////////
 354 protected:
 355    virtual void trace(GC *);
 356 public:
 357 };
 358
 359 ///////////////////////////////////////////////////////////////////////////////
 360 //
 361 // Class for datatype constructor Exp::SEQexp
 362 //
 363 ///////////////////////////////////////////////////////////////////////////////
 364 class Exp_SEQexp : public a_Exp {
 365 public:
 366 #line 16 "setl-ast.ph"
 367    Exps SEQexp;
 368    Exp_SEQexp (Exps x_SEQexp);
 369    ~Exp_SEQexp();
 370    ////////////////////////////////////////////////////////////////////////////
 371    //
 372    // Method for garbage collection tracing
 373    //
 374    ////////////////////////////////////////////////////////////////////////////
 375 protected:
 376    virtual void trace(GC *);
 377 public:
 378 };
 379
 380 ///////////////////////////////////////////////////////////////////////////////
 381 //
 382 // Class for datatype constructor Exp::LETexp
 383 //
 384 ///////////////////////////////////////////////////////////////////////////////
 385 class Exp_LETexp : public a_Exp {
 386 public:
 387 #line 17 "setl-ast.ph"
 388    Decls _1; Exp _2;
 389    Exp_LETexp (Decls x_1, Exp x_2);
 390    ~Exp_LETexp();
 391    ////////////////////////////////////////////////////////////////////////////
 392    //
 393    // Method for garbage collection tracing
 394    //
 395    ////////////////////////////////////////////////////////////////////////////
 396 protected:
 397    virtual void trace(GC *);
 398 public:
 399 };
 400
 401 ///////////////////////////////////////////////////////////////////////////////
 402 //
 403 // Class for datatype constructor Exp::PRIMexp
 404 //
 405 ///////////////////////////////////////////////////////////////////////////////
 406 class Exp_PRIMexp : public a_Exp {
 407 public:
 408 #line 18 "setl-ast.ph"
 409    Prim PRIMexp;
 410    Exp_PRIMexp (Prim x_PRIMexp);
 411    ~Exp_PRIMexp();
 412    ////////////////////////////////////////////////////////////////////////////
 413    //
 414    // Method for garbage collection tracing
 415    //
 416    ////////////////////////////////////////////////////////////////////////////
 417 protected:
 418    virtual void trace(GC *);
 419 public:
 420 };
 421
 422 ///////////////////////////////////////////////////////////////////////////////
 423 //
 424 // Datatype constructor functions for Exp
 425 //
 426 ///////////////////////////////////////////////////////////////////////////////
 427 extern a_Exp * IDexp (Id x_IDexp);
 428 extern a_Exp * LITexp (Literal x_LITexp);
 429 extern a_Exp * APPexp (Exp x_1, Exp x_2);
 430 extern a_Exp * TUPLEexp (Exps x_TUPLEexp);
 431 extern a_Exp * RECORDexp (LabeledExps x_RECORDexp);
 432 extern a_Exp * SETexp (Exps x_SETexp);
 433 extern a_Exp * CASEexp (Exp x_1, Exps x_2);
 434 extern a_Exp * IFexp (Exp x_1, Exp x_2, Exp x_3);
 435 extern a_Exp * WHILEexp (Exp x_1, Exp x_2);
 436 extern a_Exp * SEQexp (Exps x_SEQexp);
 437 extern a_Exp * LETexp (Decls x_1, Exp x_2);
 438 extern a_Exp * PRIMexp (Prim x_PRIMexp);
 439
 440
 441 ///////////////////////////////////////////////////////////////////////////////
 442 //
 443 //  Pretty printing methods for Prim
 444 //
 445 ///////////////////////////////////////////////////////////////////////////////
 446 class PrettyOStream;
 447 extern ostream& operator<<(ostream&, Prim);
 448 extern PrettyOStream& operator<<(PrettyOStream&, Prim);
 449 ///////////////////////////////////////////////////////////////////////////////
 450 //
 451 // Base class for datatype Decl
 452 //
 453 ///////////////////////////////////////////////////////////////////////////////
 454 class a_Decl : public GCObject {
 455 public:
 456    enum Tag_Decl {
 457       tag_TYPEdecl = 0, tag_DATATYPEdecl = 1
 458    };
 459
 460 public:
 461    virtual ~a_Decl();
 462    ////////////////////////////////////////////////////////////////////////////
 463    //
 464    // Method for garbage collection tracing
 465    //
 466    ////////////////////////////////////////////////////////////////////////////
 467 protected:
 468    virtual void trace(GC *);
 469 public:
 470 };
 471 inline int boxed(const a_Decl *) { return 1; }
 472 ///////////////////////////////////////////////////////////////////////////////
 473 //
 474 // Embbeded tag extraction functions
 475 //
 476 ///////////////////////////////////////////////////////////////////////////////
 477 inline int untagp(const a_Decl * x)
 478    { return (unsigned long)x & 3; }
 479 inline a_Decl * derefp(const a_Decl * x)
 480    { return (a_Decl*)((unsigned long)x & ~3); }
 481 inline int untag(const a_Decl * x) { return untagp(x); }
 482 ///////////////////////////////////////////////////////////////////////////////
 483 //
 484 // Class for datatype constructor Decl::TYPEdecl
 485 //
 486 ///////////////////////////////////////////////////////////////////////////////
 487 class Decl_TYPEdecl : public a_Decl {
 488 public:
 489 #line 26 "setl-ast.ph"
 490    Id _1; Ids _2; Ty _3;
 491    Decl_TYPEdecl (Id x_1, Ids x_2, Ty x_3);
 492    ~Decl_TYPEdecl();
 493    ////////////////////////////////////////////////////////////////////////////
 494    //
 495    // Method for garbage collection tracing
 496    //
 497    ////////////////////////////////////////////////////////////////////////////
 498 protected:
 499    virtual void trace(GC *);
 500 public:
 501 };
 502
 503 ///////////////////////////////////////////////////////////////////////////////
 504 //
 505 // Class for datatype constructor Decl::DATATYPEdecl
 506 //
 507 ///////////////////////////////////////////////////////////////////////////////
 508 class Decl_DATATYPEdecl : public a_Decl {
 509 public:
 510 #line 28 "setl-ast.ph"
 511    Id _1; Ids _2; Terms _3;
 512    Decl_DATATYPEdecl (Id x_1, Ids x_2, Terms x_3);
 513    ~Decl_DATATYPEdecl();
 514    ////////////////////////////////////////////////////////////////////////////
 515    //
 516    // Method for garbage collection tracing
 517    //
 518    ////////////////////////////////////////////////////////////////////////////
 519 protected:
 520    virtual void trace(GC *);
 521 public:
 522 };
 523
 524 ///////////////////////////////////////////////////////////////////////////////
 525 //
 526 // Datatype constructor functions for Decl
 527 //
 528 ///////////////////////////////////////////////////////////////////////////////
 529 extern a_Decl * TYPEdecl (Id x_1, Ids x_2, Ty x_3);
 530 extern a_Decl * DATATYPEdecl (Id x_1, Ids x_2, Terms x_3);
 531
 532 ///////////////////////////////////////////////////////////////////////////////
 533 //
 534 // Class for datatype constructor Term::TERM
 535 //
 536 ///////////////////////////////////////////////////////////////////////////////
 537 class a_Term : public GCObject {
 538 public:
 539 #line 30 "setl-ast.ph"
 540    Id _1; Ty _2;
 541    a_Term (Id x_1, Ty x_2);
 542    virtual ~a_Term();
 543    ////////////////////////////////////////////////////////////////////////////
 544    //
 545    // Method for garbage collection tracing
 546    //
 547    ////////////////////////////////////////////////////////////////////////////
 548 protected:
 549    virtual void trace(GC *);
 550 public:
 551 };
 552 inline int boxed(const a_Term *) { return 1; }
 553 inline int untag(const a_Term *) { return 0; }
 554 ///////////////////////////////////////////////////////////////////////////////
 555 //
 556 // Datatype constructor functions for Term
 557 //
 558 ///////////////////////////////////////////////////////////////////////////////
 559 extern a_Term * TERM (Id x_1, Ty x_2);
 560
 561 ///////////////////////////////////////////////////////////////////////////////
 562 //
 563 // Class for datatype constructor Ty::VARty
 564 //
 565 ///////////////////////////////////////////////////////////////////////////////
 566 class a_Ty : public GCObject {
 567 public:
 568 #line 34 "setl-ast.ph"
 569    Ty VARty;
 570    a_Ty (Ty x_VARty);
 571    virtual ~a_Ty();
 572    ////////////////////////////////////////////////////////////////////////////
 573    //
 574    // Method for garbage collection tracing
 575    //
 576    ////////////////////////////////////////////////////////////////////////////
 577 protected:
 578    virtual void trace(GC *);
 579 public:
 580 };
 581 inline int boxed(const a_Ty * x) { return x != 0; }
 582 inline int untag(const a_Ty * x) { return x ? 1 : 0; }
 583 ///////////////////////////////////////////////////////////////////////////////
 584 //
 585 // Datatype constructor functions for Ty
 586 //
 587 ///////////////////////////////////////////////////////////////////////////////
 588 extern a_Ty * VARty (Ty x_VARty);
 589
 590 ///////////////////////////////////////////////////////////////////////////////
 591 //
 592 // Class for datatype constructor LabeledExp::LABELEDexp
 593 //
 594 ///////////////////////////////////////////////////////////////////////////////
 595 class a_LabeledExp : public GCObject {
 596 public:
 597 #line 36 "setl-ast.ph"
 598    Id id; Exp exp;
 599    a_LabeledExp (Id x_id, Exp x_exp);
 600    virtual ~a_LabeledExp();
 601    ////////////////////////////////////////////////////////////////////////////
 602    //
 603    // Method for garbage collection tracing
 604    //
 605    ////////////////////////////////////////////////////////////////////////////
 606 protected:
 607    virtual void trace(GC *);
 608 public:
 609 };
 610 inline int boxed(const a_LabeledExp *) { return 1; }
 611 inline int untag(const a_LabeledExp *) { return 0; }
 612 ///////////////////////////////////////////////////////////////////////////////
 613 //
 614 // Datatype constructor functions for LabeledExp
 615 //
 616 ///////////////////////////////////////////////////////////////////////////////
 617 extern a_LabeledExp * LABELEDexp (Id x_id, Exp x_exp);
 618
 619 ///////////////////////////////////////////////////////////////////////////////
 620 //
 621 // Base class for datatype Literal
 622 //
 623 ///////////////////////////////////////////////////////////////////////////////
 624 class a_Literal : public GCObject {
 625 public:
 626    enum Tag_Literal {
 627       tag_INTlit = 0, tag_REALlit = 1, tag_STRINGlit = 2,
 628       tag_CHARlit = 3
 629    };
 630
 631 public:
 632    virtual ~a_Literal();
 633    ////////////////////////////////////////////////////////////////////////////
 634    //
 635    // Method for garbage collection tracing
 636    //
 637    ////////////////////////////////////////////////////////////////////////////
 638 protected:
 639    virtual void trace(GC *);
 640 public:
 641 };
 642 inline int boxed(const a_Literal *) { return 1; }
 643 ///////////////////////////////////////////////////////////////////////////////
 644 //
 645 // Embbeded tag extraction functions
 646 //
 647 ///////////////////////////////////////////////////////////////////////////////
 648 inline int untagp(const a_Literal * x)
 649    { return (unsigned long)x & 3; }
 650 inline a_Literal * derefp(const a_Literal * x)
 651    { return (a_Literal*)((unsigned long)x & ~3); }
 652 inline int untag(const a_Literal * x) { return untagp(x); }
 653 ///////////////////////////////////////////////////////////////////////////////
 654 //
 655 // Class for datatype constructor Literal::INTlit
 656 //
 657 ///////////////////////////////////////////////////////////////////////////////
 658 class Literal_INTlit : public a_Literal {
 659 public:
 660 #line 38 "setl-ast.ph"
 661    int INTlit;
 662    Literal_INTlit (int x_INTlit);
 663    ~Literal_INTlit();
 664    ////////////////////////////////////////////////////////////////////////////
 665    //
 666    // Method for garbage collection tracing
 667    //
 668    ////////////////////////////////////////////////////////////////////////////
 669 protected:
 670    virtual void trace(GC *);
 671 public:
 672 };
 673
 674 ///////////////////////////////////////////////////////////////////////////////
 675 //
 676 // Class for datatype constructor Literal::REALlit
 677 //
 678 ///////////////////////////////////////////////////////////////////////////////
 679 class Literal_REALlit : public a_Literal {
 680 public:
 681 #line 40 "setl-ast.ph"
 682    double REALlit;
 683    Literal_REALlit (double x_REALlit);
 684    ~Literal_REALlit();
 685    ////////////////////////////////////////////////////////////////////////////
 686    //
 687    // Method for garbage collection tracing
 688    //
 689    ////////////////////////////////////////////////////////////////////////////
 690 protected:
 691    virtual void trace(GC *);
 692 public:
 693 };
 694
 695 ///////////////////////////////////////////////////////////////////////////////
 696 //
 697 // Class for datatype constructor Literal::STRINGlit
 698 //
 699 ///////////////////////////////////////////////////////////////////////////////
 700 class Literal_STRINGlit : public a_Literal {
 701 public:
 702 #line 41 "setl-ast.ph"
 703    char const * STRINGlit;
 704    Literal_STRINGlit (char const * x_STRINGlit);
 705    ~Literal_STRINGlit();
 706    ////////////////////////////////////////////////////////////////////////////
 707    //
 708    // Method for garbage collection tracing
 709    //
 710    ////////////////////////////////////////////////////////////////////////////
 711 protected:
 712    virtual void trace(GC *);
 713 public:
 714 };
 715
 716 ///////////////////////////////////////////////////////////////////////////////
 717 //
 718 // Class for datatype constructor Literal::CHARlit
 719 //
 720 ///////////////////////////////////////////////////////////////////////////////
 721 class Literal_CHARlit : public a_Literal {
 722 public:
 723 #line 42 "setl-ast.ph"
 724    char CHARlit;
 725    Literal_CHARlit (char x_CHARlit);
 726    ~Literal_CHARlit();
 727    ////////////////////////////////////////////////////////////////////////////
 728    //
 729    // Method for garbage collection tracing
 730    //
 731    ////////////////////////////////////////////////////////////////////////////
 732 protected:
 733    virtual void trace(GC *);
 734 public:
 735 };
 736
 737 ///////////////////////////////////////////////////////////////////////////////
 738 //
 739 // Datatype constructor functions for Literal
 740 //
 741 ///////////////////////////////////////////////////////////////////////////////
 742 extern a_Literal * INTlit (int x_INTlit);
 743 extern a_Literal * REALlit (double x_REALlit);
 744 extern a_Literal * STRINGlit (char const * x_STRINGlit);
 745 extern a_Literal * CHARlit (char x_CHARlit);
 746
 747 #line 51 "setl-ast.ph"
 748 #line 51 "setl-ast.ph"
 749
 750
 751 #endif
 752 #line 54 "setl-ast.ph"
 753 /*
 754 ------------------------------- Statistics -------------------------------
 755 Merge matching rules         = yes
 756 Number of DFA nodes merged   = 0
 757 Number of ifs generated      = 0
 758 Number of switches generated = 0
 759 Number of labels             = 0
 760 Number of gotos              = 0
 761 Adaptive matching            = enabled
 762 Fast string matching         = enabled
 763 Inline downcasts             = enabled
 764 --------------------------------------------------------------------------
 765 */