prop-src/prog.C

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //  This file is generated automatically using Prop (version 2.3.3),
   3 //  last updated on Mar 27, 1997.
   4 //  The original source file is "prog.pC".
   5 ///////////////////////////////////////////////////////////////////////////////
   6
   7 #define PROP_REWRITING_USED
   8 #define PROP_PRINTER_USED
   9 #define PROP_QUARK_USED
  10 #include <propdefs.h>
  11 #line 1 "prog.pC"
  12 /////////////////////////////////////////////////////////////////////////////
  13 //  This test implements a rewrite based simplifier for the abstract
  14 //  syntax of a toy imperative language.
  15 /////////////////////////////////////////////////////////////////////////////
  16 #include <iostream.h>
  17
  18 /////////////////////////////////////////////////////////////////////////////
  19 //  The following recursive type equations define the abstract syntax
  20 //  of our small language.
  21 //  ( Note: we define our own boolean type because not all C++ compilers
  22 //    have bool built-in yet. )
  23 /////////////////////////////////////////////////////////////////////////////
  24 #line 13 "prog.pC"
  25 #line 50 "prog.pC"
  26 ///////////////////////////////////////////////////////////////////////////////
  27 //
  28 // Forward class definition for List<T>
  29 //
  30 ///////////////////////////////////////////////////////////////////////////////
  31 #ifndef datatype_List_defined
  32 #define datatype_List_defined
  33 template <class T> class a_List;
  34 #define List(T) a_List<T> *
  35 #endif
  36
  37 #  define nil_1_ 0
  38
  39 enum BOOL {
  40    False = 0, True = 1
  41 };
  42
  43
  44
  45 ///////////////////////////////////////////////////////////////////////////////
  46 //
  47 // Forward class definition for Exp
  48 //
  49 ///////////////////////////////////////////////////////////////////////////////
  50 #ifndef datatype_Exp_defined
  51 #define datatype_Exp_defined
  52    class a_Exp;
  53    typedef a_Exp * Exp;
  54 #endif
  55
  56 enum BinOp {
  57    add = 0, sub = 1, mul = 2,
  58    divide = 3, mod = 4, logical_and = 5,
  59    logical_or = 6, eq = 7, ge = 8,
  60    le = 9, lt = 10, gt = 11,
  61    ne = 12
  62 };
  63
  64
  65
  66 enum UnaryOp {
  67    uminus = 0, logical_not = 1
  68 };
  69
  70
  71
  72 ///////////////////////////////////////////////////////////////////////////////
  73 //
  74 // Forward class definition for Stmt
  75 //
  76 ///////////////////////////////////////////////////////////////////////////////
  77 #ifndef datatype_Stmt_defined
  78 #define datatype_Stmt_defined
  79    class a_Stmt;
  80    typedef a_Stmt * Stmt;
  81 #endif
  82
  83 ///////////////////////////////////////////////////////////////////////////////
  84 //
  85 // Forward class definition for Type
  86 //
  87 ///////////////////////////////////////////////////////////////////////////////
  88 #ifndef datatype_Type_defined
  89 #define datatype_Type_defined
  90    class a_Type;
  91    typedef a_Type * Type;
  92 #endif
  93
  94 ///////////////////////////////////////////////////////////////////////////////
  95 //
  96 // Forward class definition for Decl
  97 //
  98 ///////////////////////////////////////////////////////////////////////////////
  99 #ifndef datatype_Decl_defined
 100 #define datatype_Decl_defined
 101    class a_Decl;
 102    typedef a_Decl * Decl;
 103 #endif
 104
 105 ///////////////////////////////////////////////////////////////////////////////
 106 //
 107 // Forward class definition for LabeledType
 108 //
 109 ///////////////////////////////////////////////////////////////////////////////
 110 #ifndef datatype_LabeledType_defined
 111 #define datatype_LabeledType_defined
 112    class a_LabeledType;
 113    typedef a_LabeledType * LabeledType;
 114 #endif
 115
 116 ///////////////////////////////////////////////////////////////////////////////
 117 // Definition of type Id
 118 ///////////////////////////////////////////////////////////////////////////////
 119 #line 49 "prog.pC"
 120 typedef char const * Id;
 121
 122 ///////////////////////////////////////////////////////////////////////////////
 123 //
 124 // Class for datatype constructor List<T>::#[...]
 125 //
 126 ///////////////////////////////////////////////////////////////////////////////
 127 template <class T> class a_List : public TermObj {
 128 public:
 129 #line 13 "prog.pC"
 130    T _1; a_List<T> *  _2;
 131    inline a_List (T x_1, a_List<T> *  x_2)
 132     : _1(x_1), _2(x_2)
 133    {
 134    }
 135    inline a_List (T x_1)
 136     : _1(x_1), _2((a_List<T> *)0)
 137    {
 138    }
 139 };
 140 template <class T> inline int boxed(const a_List<T> * x) { return x != 0; }
 141 template <class T> inline int untag(const a_List<T> * x) { return x ? 1 : 0; }
 142 ///////////////////////////////////////////////////////////////////////////////
 143 //
 144 //  Pretty printing methods for List<T>
 145 //
 146 ///////////////////////////////////////////////////////////////////////////////
 147 class PrettyOStream;
 148 template <class T> extern ostream& operator<<(ostream&, List(T));
 149 template <class T> extern PrettyOStream& operator<<(PrettyOStream&, List(T));
 150 ///////////////////////////////////////////////////////////////////////////////
 151 //
 152 // Datatype constructor functions for List<T>
 153 //
 154 ///////////////////////////////////////////////////////////////////////////////
 155 template <class T> inline a_List<T> * list_1_ (T x_1, a_List<T> *  x_2)
 156 {
 157    return new a_List<T> (x_1, x_2);
 158 }
 159 template <class T> inline a_List<T> * list_1_ (T x_1)
 160 {
 161    return new a_List<T> (x_1);
 162 }
 163 ///////////////////////////////////////////////////////////////////////////////
 164 //
 165 // Downcasting functions for List<T>
 166 //
 167 ///////////////////////////////////////////////////////////////////////////////
 168
 169
 170
 171 ///////////////////////////////////////////////////////////////////////////////
 172 //
 173 //  Pretty printing methods for BOOL
 174 //
 175 ///////////////////////////////////////////////////////////////////////////////
 176 class PrettyOStream;
 177 extern ostream& operator<<(ostream&, BOOL);
 178 extern PrettyOStream& operator<<(PrettyOStream&, BOOL);
 179 ///////////////////////////////////////////////////////////////////////////////
 180 //
 181 // Base class for datatype Exp
 182 //
 183 ///////////////////////////////////////////////////////////////////////////////
 184 class a_Exp : public TermObj {
 185 public:
 186    enum Tag_Exp {
 187       tag_integer = 0, tag_real = 1, tag_string = 2,
 188       tag_boolean = 3, tag_binop = 4, tag_unaryop = 5,
 189       tag_var = 6
 190    };
 191
 192 public:
 193    const Tag_Exp tag__; // variant tag
 194 protected:
 195    inline a_Exp(Tag_Exp t__) : tag__(t__) {}
 196 public:
 197 };
 198 inline int boxed(const a_Exp *) { return 1; }
 199 inline int untag(const a_Exp * x) { return x->tag__; }
 200 ///////////////////////////////////////////////////////////////////////////////
 201 //
 202 //  Pretty printing methods for Exp
 203 //
 204 ///////////////////////////////////////////////////////////////////////////////
 205 class PrettyOStream;
 206 extern ostream& operator<<(ostream&, Exp);
 207 extern PrettyOStream& operator<<(PrettyOStream&, Exp);
 208 ///////////////////////////////////////////////////////////////////////////////
 209 //
 210 // Class for datatype constructor Exp::integer
 211 //
 212 ///////////////////////////////////////////////////////////////////////////////
 213 class Exp_integer : public a_Exp {
 214 public:
 215 #line 18 "prog.pC"
 216    int integer;
 217    inline Exp_integer (int x_integer)
 218     : a_Exp(tag_integer), integer(x_integer)
 219    {
 220    }
 221 };
 222
 223 ///////////////////////////////////////////////////////////////////////////////
 224 //
 225 // Class for datatype constructor Exp::real
 226 //
 227 ///////////////////////////////////////////////////////////////////////////////
 228 class Exp_real : public a_Exp {
 229 public:
 230 #line 19 "prog.pC"
 231    double real;
 232    inline Exp_real (double x_real)
 233     : a_Exp(tag_real), real(x_real)
 234    {
 235    }
 236 };
 237
 238 ///////////////////////////////////////////////////////////////////////////////
 239 //
 240 // Class for datatype constructor Exp::string
 241 //
 242 ///////////////////////////////////////////////////////////////////////////////
 243 class Exp_string : public a_Exp {
 244 public:
 245 #line 20 "prog.pC"
 246    char * string;
 247    inline Exp_string (char * x_string)
 248     : a_Exp(tag_string), string(x_string)
 249    {
 250    }
 251 };
 252
 253 ///////////////////////////////////////////////////////////////////////////////
 254 //
 255 // Class for datatype constructor Exp::boolean
 256 //
 257 ///////////////////////////////////////////////////////////////////////////////
 258 class Exp_boolean : public a_Exp {
 259 public:
 260 #line 21 "prog.pC"
 261    BOOL boolean;
 262    inline Exp_boolean (BOOL x_boolean)
 263     : a_Exp(tag_boolean), boolean(x_boolean)
 264    {
 265    }
 266 };
 267
 268 ///////////////////////////////////////////////////////////////////////////////
 269 //
 270 // Class for datatype constructor Exp::binop
 271 //
 272 ///////////////////////////////////////////////////////////////////////////////
 273 class Exp_binop : public a_Exp {
 274 public:
 275 #line 22 "prog.pC"
 276    BinOp _1; Exp _2; Exp _3;
 277    inline Exp_binop (BinOp x_1, Exp x_2, Exp x_3)
 278     : a_Exp(tag_binop), _1(x_1), _2(x_2), _3(x_3)
 279    {
 280    }
 281 };
 282
 283 ///////////////////////////////////////////////////////////////////////////////
 284 //
 285 // Class for datatype constructor Exp::unaryop
 286 //
 287 ///////////////////////////////////////////////////////////////////////////////
 288 class Exp_unaryop : public a_Exp {
 289 public:
 290 #line 23 "prog.pC"
 291    UnaryOp _1; Exp _2;
 292    inline Exp_unaryop (UnaryOp x_1, Exp x_2)
 293     : a_Exp(tag_unaryop), _1(x_1), _2(x_2)
 294    {
 295    }
 296 };
 297
 298 ///////////////////////////////////////////////////////////////////////////////
 299 //
 300 // Class for datatype constructor Exp::var
 301 //
 302 ///////////////////////////////////////////////////////////////////////////////
 303 class Exp_var : public a_Exp {
 304 public:
 305 #line 24 "prog.pC"
 306    Id var;
 307    inline Exp_var (Id x_var)
 308     : a_Exp(tag_var), var(x_var)
 309    {
 310    }
 311 };
 312
 313 ///////////////////////////////////////////////////////////////////////////////
 314 //
 315 // Datatype constructor functions for Exp
 316 //
 317 ///////////////////////////////////////////////////////////////////////////////
 318 inline a_Exp * integer (int x_integer)
 319 {
 320    return new Exp_integer (x_integer);
 321 }
 322 inline a_Exp * real (double x_real)
 323 {
 324    return new Exp_real (x_real);
 325 }
 326 inline a_Exp * string (char * x_string)
 327 {
 328    return new Exp_string (x_string);
 329 }
 330 inline a_Exp * boolean (BOOL x_boolean)
 331 {
 332    return new Exp_boolean (x_boolean);
 333 }
 334 inline a_Exp * binop (BinOp x_1, Exp x_2, Exp x_3)
 335 {
 336    return new Exp_binop (x_1, x_2, x_3);
 337 }
 338 inline a_Exp * unaryop (UnaryOp x_1, Exp x_2)
 339 {
 340    return new Exp_unaryop (x_1, x_2);
 341 }
 342 inline a_Exp * var (Id x_var)
 343 {
 344    return new Exp_var (x_var);
 345 }
 346 ///////////////////////////////////////////////////////////////////////////////
 347 //
 348 // Downcasting functions for Exp
 349 //
 350 ///////////////////////////////////////////////////////////////////////////////
 351 inline Exp_integer * _integer(const a_Exp * _x_) { return (Exp_integer *)_x_; }
 352 inline Exp_real * _real(const a_Exp * _x_) { return (Exp_real *)_x_; }
 353 inline Exp_string * _string(const a_Exp * _x_) { return (Exp_string *)_x_; }
 354 inline Exp_boolean * _boolean(const a_Exp * _x_) { return (Exp_boolean *)_x_; }
 355 inline Exp_binop * _binop(const a_Exp * _x_) { return (Exp_binop *)_x_; }
 356 inline Exp_unaryop * _unaryop(const a_Exp * _x_) { return (Exp_unaryop *)_x_; }
 357 inline Exp_var * _var(const a_Exp * _x_) { return (Exp_var *)_x_; }
 358
 359
 360 ///////////////////////////////////////////////////////////////////////////////
 361 //
 362 //  Pretty printing methods for BinOp
 363 //
 364 ///////////////////////////////////////////////////////////////////////////////
 365 class PrettyOStream;
 366 extern ostream& operator<<(ostream&, BinOp);
 367 extern PrettyOStream& operator<<(PrettyOStream&, BinOp);
 368 ///////////////////////////////////////////////////////////////////////////////
 369 //
 370 //  Pretty printing methods for UnaryOp
 371 //
 372 ///////////////////////////////////////////////////////////////////////////////
 373 class PrettyOStream;
 374 extern ostream& operator<<(ostream&, UnaryOp);
 375 extern PrettyOStream& operator<<(PrettyOStream&, UnaryOp);
 376 ///////////////////////////////////////////////////////////////////////////////
 377 //
 378 // Base class for datatype Stmt
 379 //
 380 ///////////////////////////////////////////////////////////////////////////////
 381 class a_Stmt : public TermObj {
 382 public:
 383    enum Tag_Stmt {
 384       tag_assign_stmt = 0, tag_while_stmt = 1, tag_if_stmt = 2,
 385       tag_print_stmt = 3, tag_block_stmt = 4
 386    };
 387
 388 public:
 389    const Tag_Stmt tag__; // variant tag
 390 protected:
 391    inline a_Stmt(Tag_Stmt t__) : tag__(t__) {}
 392 public:
 393 };
 394 inline int boxed(const a_Stmt *) { return 1; }
 395 inline int untag(const a_Stmt * x) { return x->tag__; }
 396 ///////////////////////////////////////////////////////////////////////////////
 397 //
 398 //  Pretty printing methods for Stmt
 399 //
 400 ///////////////////////////////////////////////////////////////////////////////
 401 class PrettyOStream;
 402 extern ostream& operator<<(ostream&, Stmt);
 403 extern PrettyOStream& operator<<(PrettyOStream&, Stmt);
 404 ///////////////////////////////////////////////////////////////////////////////
 405 //
 406 // Class for datatype constructor Stmt::assign_stmt
 407 //
 408 ///////////////////////////////////////////////////////////////////////////////
 409 class Stmt_assign_stmt : public a_Stmt {
 410 public:
 411 #line 32 "prog.pC"
 412    Id _1; Exp _2;
 413    inline Stmt_assign_stmt (Id x_1, Exp x_2)
 414     : a_Stmt(tag_assign_stmt), _1(x_1), _2(x_2)
 415    {
 416    }
 417 };
 418
 419 ///////////////////////////////////////////////////////////////////////////////
 420 //
 421 // Class for datatype constructor Stmt::while_stmt
 422 //
 423 ///////////////////////////////////////////////////////////////////////////////
 424 class Stmt_while_stmt : public a_Stmt {
 425 public:
 426 #line 33 "prog.pC"
 427    Exp _1; Stmt _2;
 428    inline Stmt_while_stmt (Exp x_1, Stmt x_2)
 429     : a_Stmt(tag_while_stmt), _1(x_1), _2(x_2)
 430    {
 431    }
 432 };
 433
 434 ///////////////////////////////////////////////////////////////////////////////
 435 //
 436 // Class for datatype constructor Stmt::if_stmt
 437 //
 438 ///////////////////////////////////////////////////////////////////////////////
 439 class Stmt_if_stmt : public a_Stmt {
 440 public:
 441 #line 34 "prog.pC"
 442    Exp _1; Stmt _2; Stmt _3;
 443    inline Stmt_if_stmt (Exp x_1, Stmt x_2, Stmt x_3)
 444     : a_Stmt(tag_if_stmt), _1(x_1), _2(x_2), _3(x_3)
 445    {
 446    }
 447 };
 448
 449 ///////////////////////////////////////////////////////////////////////////////
 450 //
 451 // Class for datatype constructor Stmt::print_stmt
 452 //
 453 ///////////////////////////////////////////////////////////////////////////////
 454 class Stmt_print_stmt : public a_Stmt {
 455 public:
 456 #line 35 "prog.pC"
 457    Exp print_stmt;
 458    inline Stmt_print_stmt (Exp x_print_stmt)
 459     : a_Stmt(tag_print_stmt), print_stmt(x_print_stmt)
 460    {
 461    }
 462 };
 463
 464 ///////////////////////////////////////////////////////////////////////////////
 465 //
 466 // Class for datatype constructor Stmt::block_stmt
 467 //
 468 ///////////////////////////////////////////////////////////////////////////////
 469 class Stmt_block_stmt : public a_Stmt {
 470 public:
 471 #line 36 "prog.pC"
 472    a_List<Decl> *  _1; a_List<Stmt> *  _2;
 473    inline Stmt_block_stmt (a_List<Decl> *  x_1, a_List<Stmt> *  x_2)
 474     : a_Stmt(tag_block_stmt), _1(x_1), _2(x_2)
 475    {
 476    }
 477 };
 478
 479 ///////////////////////////////////////////////////////////////////////////////
 480 //
 481 // Datatype constructor functions for Stmt
 482 //
 483 ///////////////////////////////////////////////////////////////////////////////
 484 inline a_Stmt * assign_stmt (Id x_1, Exp x_2)
 485 {
 486    return new Stmt_assign_stmt (x_1, x_2);
 487 }
 488 inline a_Stmt * while_stmt (Exp x_1, Stmt x_2)
 489 {
 490    return new Stmt_while_stmt (x_1, x_2);
 491 }
 492 inline a_Stmt * if_stmt (Exp x_1, Stmt x_2, Stmt x_3)
 493 {
 494    return new Stmt_if_stmt (x_1, x_2, x_3);
 495 }
 496 inline a_Stmt * print_stmt (Exp x_print_stmt)
 497 {
 498    return new Stmt_print_stmt (x_print_stmt);
 499 }
 500 inline a_Stmt * block_stmt (a_List<Decl> *  x_1, a_List<Stmt> *  x_2)
 501 {
 502    return new Stmt_block_stmt (x_1, x_2);
 503 }
 504 ///////////////////////////////////////////////////////////////////////////////
 505 //
 506 // Downcasting functions for Stmt
 507 //
 508 ///////////////////////////////////////////////////////////////////////////////
 509 inline Stmt_assign_stmt * _assign_stmt(const a_Stmt * _x_) { return (Stmt_assign_stmt *)_x_; }
 510 inline Stmt_while_stmt * _while_stmt(const a_Stmt * _x_) { return (Stmt_while_stmt *)_x_; }
 511 inline Stmt_if_stmt * _if_stmt(const a_Stmt * _x_) { return (Stmt_if_stmt *)_x_; }
 512 inline Stmt_print_stmt * _print_stmt(const a_Stmt * _x_) { return (Stmt_print_stmt *)_x_; }
 513 inline Stmt_block_stmt * _block_stmt(const a_Stmt * _x_) { return (Stmt_block_stmt *)_x_; }
 514
 515 ///////////////////////////////////////////////////////////////////////////////
 516 //
 517 // Base class for datatype Type
 518 //
 519 ///////////////////////////////////////////////////////////////////////////////
 520 class a_Type : public TermObj {
 521 public:
 522    enum Tag_Type {
 523       tag_primitive_type = 0, tag_pointer_type = 1, tag_array_type = 2,
 524       tag_function_type = 3, tag_tuple_type = 4, tag_record_type = 5
 525    };
 526
 527 public:
 528    const Tag_Type tag__; // variant tag
 529 protected:
 530    inline a_Type(Tag_Type t__) : tag__(t__) {}
 531 public:
 532 };
 533 inline int boxed(const a_Type *) { return 1; }
 534 inline int untag(const a_Type * x) { return x->tag__; }
 535 ///////////////////////////////////////////////////////////////////////////////
 536 //
 537 //  Pretty printing methods for Type
 538 //
 539 ///////////////////////////////////////////////////////////////////////////////
 540 class PrettyOStream;
 541 extern ostream& operator<<(ostream&, Type);
 542 extern PrettyOStream& operator<<(PrettyOStream&, Type);
 543 ///////////////////////////////////////////////////////////////////////////////
 544 //
 545 // Class for datatype constructor Type::primitive_type
 546 //
 547 ///////////////////////////////////////////////////////////////////////////////
 548 class Type_primitive_type : public a_Type {
 549 public:
 550 #line 38 "prog.pC"
 551    Id primitive_type;
 552    inline Type_primitive_type (Id x_primitive_type)
 553     : a_Type(tag_primitive_type), primitive_type(x_primitive_type)
 554    {
 555    }
 556 };
 557
 558 ///////////////////////////////////////////////////////////////////////////////
 559 //
 560 // Class for datatype constructor Type::pointer_type
 561 //
 562 ///////////////////////////////////////////////////////////////////////////////
 563 class Type_pointer_type : public a_Type {
 564 public:
 565 #line 39 "prog.pC"
 566    Type pointer_type;
 567    inline Type_pointer_type (Type x_pointer_type)
 568     : a_Type(tag_pointer_type), pointer_type(x_pointer_type)
 569    {
 570    }
 571 };
 572
 573 ///////////////////////////////////////////////////////////////////////////////
 574 //
 575 // Class for datatype constructor Type::array_type
 576 //
 577 ///////////////////////////////////////////////////////////////////////////////
 578 class Type_array_type : public a_Type {
 579 public:
 580 #line 40 "prog.pC"
 581    Type element; Exp bound;
 582    inline Type_array_type (Type x_element, Exp x_bound)
 583     : a_Type(tag_array_type), element(x_element), bound(x_bound)
 584    {
 585    }
 586 };
 587
 588 ///////////////////////////////////////////////////////////////////////////////
 589 //
 590 // Class for datatype constructor Type::function_type
 591 //
 592 ///////////////////////////////////////////////////////////////////////////////
 593 class Type_function_type : public a_Type {
 594 public:
 595 #line 41 "prog.pC"
 596    Type arg; Type ret;
 597    inline Type_function_type (Type x_arg, Type x_ret)
 598     : a_Type(tag_function_type), arg(x_arg), ret(x_ret)
 599    {
 600    }
 601 };
 602
 603 ///////////////////////////////////////////////////////////////////////////////
 604 //
 605 // Class for datatype constructor Type::tuple_type
 606 //
 607 ///////////////////////////////////////////////////////////////////////////////
 608 class Type_tuple_type : public a_Type {
 609 public:
 610 #line 42 "prog.pC"
 611    a_List<Type> *  tuple_type;
 612    inline Type_tuple_type (a_List<Type> *  x_tuple_type)
 613     : a_Type(tag_tuple_type), tuple_type(x_tuple_type)
 614    {
 615    }
 616 };
 617
 618 ///////////////////////////////////////////////////////////////////////////////
 619 //
 620 // Class for datatype constructor Type::record_type
 621 //
 622 ///////////////////////////////////////////////////////////////////////////////
 623 class Type_record_type : public a_Type {
 624 public:
 625 #line 43 "prog.pC"
 626    a_List<LabeledType> *  record_type;
 627    inline Type_record_type (a_List<LabeledType> *  x_record_type)
 628     : a_Type(tag_record_type), record_type(x_record_type)
 629    {
 630    }
 631 };
 632
 633 ///////////////////////////////////////////////////////////////////////////////
 634 //
 635 // Datatype constructor functions for Type
 636 //
 637 ///////////////////////////////////////////////////////////////////////////////
 638 inline a_Type * primitive_type (Id x_primitive_type)
 639 {
 640    return new Type_primitive_type (x_primitive_type);
 641 }
 642 inline a_Type * pointer_type (Type x_pointer_type)
 643 {
 644    return new Type_pointer_type (x_pointer_type);
 645 }
 646 inline a_Type * array_type (Type x_element, Exp x_bound)
 647 {
 648    return new Type_array_type (x_element, x_bound);
 649 }
 650 inline a_Type * function_type (Type x_arg, Type x_ret)
 651 {
 652    return new Type_function_type (x_arg, x_ret);
 653 }
 654 inline a_Type * tuple_type (a_List<Type> *  x_tuple_type)
 655 {
 656    return new Type_tuple_type (x_tuple_type);
 657 }
 658 inline a_Type * record_type (a_List<LabeledType> *  x_record_type)
 659 {
 660    return new Type_record_type (x_record_type);
 661 }
 662 ///////////////////////////////////////////////////////////////////////////////
 663 //
 664 // Downcasting functions for Type
 665 //
 666 ///////////////////////////////////////////////////////////////////////////////
 667 inline Type_primitive_type * _primitive_type(const a_Type * _x_) { return (Type_primitive_type *)_x_; }
 668 inline Type_pointer_type * _pointer_type(const a_Type * _x_) { return (Type_pointer_type *)_x_; }
 669 inline Type_array_type * _array_type(const a_Type * _x_) { return (Type_array_type *)_x_; }
 670 inline Type_function_type * _function_type(const a_Type * _x_) { return (Type_function_type *)_x_; }
 671 inline Type_tuple_type * _tuple_type(const a_Type * _x_) { return (Type_tuple_type *)_x_; }
 672 inline Type_record_type * _record_type(const a_Type * _x_) { return (Type_record_type *)_x_; }
 673
 674 ///////////////////////////////////////////////////////////////////////////////
 675 //
 676 // Class for datatype constructor Decl::decl
 677 //
 678 ///////////////////////////////////////////////////////////////////////////////
 679 class a_Decl : public TermObj {
 680 public:
 681 #line 45 "prog.pC"
 682    Id name; Type typ;
 683    inline a_Decl (Id x_name, Type x_typ)
 684     : name(x_name), typ(x_typ)
 685    {
 686    }
 687 };
 688 inline int boxed(const a_Decl *) { return 1; }
 689 inline int untag(const a_Decl *) { return 0; }
 690 ///////////////////////////////////////////////////////////////////////////////
 691 //
 692 //  Pretty printing methods for Decl
 693 //
 694 ///////////////////////////////////////////////////////////////////////////////
 695 class PrettyOStream;
 696 extern ostream& operator<<(ostream&, Decl);
 697 extern PrettyOStream& operator<<(PrettyOStream&, Decl);
 698 ///////////////////////////////////////////////////////////////////////////////
 699 //
 700 // Datatype constructor functions for Decl
 701 //
 702 ///////////////////////////////////////////////////////////////////////////////
 703 inline a_Decl * decl (Id x_name, Type x_typ)
 704 {
 705    return new a_Decl (x_name, x_typ);
 706 }
 707 ///////////////////////////////////////////////////////////////////////////////
 708 //
 709 // Downcasting functions for Decl
 710 //
 711 ///////////////////////////////////////////////////////////////////////////////
 712
 713
 714 ///////////////////////////////////////////////////////////////////////////////
 715 //
 716 // Class for datatype constructor LabeledType::labeled_type
 717 //
 718 ///////////////////////////////////////////////////////////////////////////////
 719 class a_LabeledType : public TermObj {
 720 public:
 721 #line 47 "prog.pC"
 722    Id _1; Type _2;
 723    inline a_LabeledType (Id x_1, Type x_2)
 724     : _1(x_1), _2(x_2)
 725    {
 726    }
 727 };
 728 inline int boxed(const a_LabeledType *) { return 1; }
 729 inline int untag(const a_LabeledType *) { return 0; }
 730 ///////////////////////////////////////////////////////////////////////////////
 731 //
 732 //  Pretty printing methods for LabeledType
 733 //
 734 ///////////////////////////////////////////////////////////////////////////////
 735 class PrettyOStream;
 736 extern ostream& operator<<(ostream&, LabeledType);
 737 extern PrettyOStream& operator<<(PrettyOStream&, LabeledType);
 738 ///////////////////////////////////////////////////////////////////////////////
 739 //
 740 // Datatype constructor functions for LabeledType
 741 //
 742 ///////////////////////////////////////////////////////////////////////////////
 743 inline a_LabeledType * labeled_type (Id x_1, Type x_2)
 744 {
 745    return new a_LabeledType (x_1, x_2);
 746 }
 747 ///////////////////////////////////////////////////////////////////////////////
 748 //
 749 // Downcasting functions for LabeledType
 750 //
 751 ///////////////////////////////////////////////////////////////////////////////
 752
 753
 754 #line 50 "prog.pC"
 755 #line 50 "prog.pC"
 756
 757
 758 /////////////////////////////////////////////////////////////////////////////
 759 //  Refine the implementation of the datatypes.
 760 //  The qualifiers may be also declared in the datatype definition.
 761 //  We qualify the datatypes here so that they won't clutter up
 762 //  the equations above.
 763 //
 764 //  All types are declared to be printable by
 765 //  the printer method and rewritable.
 766 /////////////////////////////////////////////////////////////////////////////
 767 #line 61 "prog.pC"
 768 #line 111 "prog.pC"
 769
 770
 771 /////////////////////////////////////////////////////////////////////////////
 772 //  Generate the interfaces to instantiated polymorphic datatypes.
 773 //  These are not strictly necessary since the instantiation is in the
 774 //  same file below.  However, in general the 'instantiate extern' declaration
 775 //  must be placed in the .h files for each instance of a polymorphic
 776 //  datatype.
 777 /////////////////////////////////////////////////////////////////////////////
 778 #line 121 "prog.pC"
 779 #line 121 "prog.pC"
 780 ///////////////////////////////////////////////////////////////////////////////
 781 //
 782 // Interface specification of datatype List<Type>
 783 //
 784 ///////////////////////////////////////////////////////////////////////////////
 785 #line 121 "prog.pC"
 786 ///////////////////////////////////////////////////////////////////////////////
 787 //
 788 // Pretty printing methods for List<Type>
 789 //
 790 ///////////////////////////////////////////////////////////////////////////////
 791 ostream& operator << (ostream& strm__, a_List<Type> *   obj__);
 792 PrettyOStream& operator << (PrettyOStream& strm__, a_List<Type> *   obj__);
 793
 794 ///////////////////////////////////////////////////////////////////////////////
 795 //
 796 // Interface specification of datatype List<Stmt>
 797 //
 798 ///////////////////////////////////////////////////////////////////////////////
 799 #line 121 "prog.pC"
 800 ///////////////////////////////////////////////////////////////////////////////
 801 //
 802 // Pretty printing methods for List<Stmt>
 803 //
 804 ///////////////////////////////////////////////////////////////////////////////
 805 ostream& operator << (ostream& strm__, a_List<Stmt> *   obj__);
 806 PrettyOStream& operator << (PrettyOStream& strm__, a_List<Stmt> *   obj__);
 807
 808 ///////////////////////////////////////////////////////////////////////////////
 809 //
 810 // Interface specification of datatype List<LabeledType>
 811 //
 812 ///////////////////////////////////////////////////////////////////////////////
 813 #line 121 "prog.pC"
 814 ///////////////////////////////////////////////////////////////////////////////
 815 //
 816 // Pretty printing methods for List<LabeledType>
 817 //
 818 ///////////////////////////////////////////////////////////////////////////////
 819 ostream& operator << (ostream& strm__, a_List<LabeledType> *   obj__);
 820 PrettyOStream& operator << (PrettyOStream& strm__, a_List<LabeledType> *   obj__);
 821
 822 ///////////////////////////////////////////////////////////////////////////////
 823 //
 824 // Interface specification of datatype List<Decl>
 825 //
 826 ///////////////////////////////////////////////////////////////////////////////
 827 #line 121 "prog.pC"
 828 ///////////////////////////////////////////////////////////////////////////////
 829 //
 830 // Pretty printing methods for List<Decl>
 831 //
 832 ///////////////////////////////////////////////////////////////////////////////
 833 ostream& operator << (ostream& strm__, a_List<Decl> *   obj__);
 834 PrettyOStream& operator << (PrettyOStream& strm__, a_List<Decl> *   obj__);
 835
 836 #line 122 "prog.pC"
 837 #line 122 "prog.pC"
 838
 839
 840 /////////////////////////////////////////////////////////////////////////////
 841 //  Now instantiate all the datatypes.
 842 /////////////////////////////////////////////////////////////////////////////
 843 #line 127 "prog.pC"
 844 #line 127 "prog.pC"
 845 ///////////////////////////////////////////////////////////////////////////////
 846 //
 847 // Interface specification of datatype Exp
 848 //
 849 ///////////////////////////////////////////////////////////////////////////////
 850 #line 127 "prog.pC"
 851 ///////////////////////////////////////////////////////////////////////////////
 852 //
 853 // Pretty printing methods for Exp
 854 //
 855 ///////////////////////////////////////////////////////////////////////////////
 856 ostream& operator << (ostream& strm__, Exp  obj__);
 857 PrettyOStream& operator << (PrettyOStream& strm__, Exp  obj__);
 858
 859 ///////////////////////////////////////////////////////////////////////////////
 860 //
 861 // Interface specification of datatype BOOL
 862 //
 863 ///////////////////////////////////////////////////////////////////////////////
 864 #line 127 "prog.pC"
 865 ///////////////////////////////////////////////////////////////////////////////
 866 //
 867 // Pretty printing methods for BOOL
 868 //
 869 ///////////////////////////////////////////////////////////////////////////////
 870 ostream& operator << (ostream& strm__, BOOL  obj__);
 871 PrettyOStream& operator << (PrettyOStream& strm__, BOOL  obj__);
 872
 873 ///////////////////////////////////////////////////////////////////////////////
 874 //
 875 // Interface specification of datatype BinOp
 876 //
 877 ///////////////////////////////////////////////////////////////////////////////
 878 #line 127 "prog.pC"
 879 ///////////////////////////////////////////////////////////////////////////////
 880 //
 881 // Pretty printing methods for BinOp
 882 //
 883 ///////////////////////////////////////////////////////////////////////////////
 884 ostream& operator << (ostream& strm__, BinOp  obj__);
 885 PrettyOStream& operator << (PrettyOStream& strm__, BinOp  obj__);
 886
 887 ///////////////////////////////////////////////////////////////////////////////
 888 //
 889 // Interface specification of datatype UnaryOp
 890 //
 891 ///////////////////////////////////////////////////////////////////////////////
 892 #line 127 "prog.pC"
 893 ///////////////////////////////////////////////////////////////////////////////
 894 //
 895 // Pretty printing methods for UnaryOp
 896 //
 897 ///////////////////////////////////////////////////////////////////////////////
 898 ostream& operator << (ostream& strm__, UnaryOp  obj__);
 899 PrettyOStream& operator << (PrettyOStream& strm__, UnaryOp  obj__);
 900
 901 ///////////////////////////////////////////////////////////////////////////////
 902 //
 903 // Interface specification of datatype Stmt
 904 //
 905 ///////////////////////////////////////////////////////////////////////////////
 906 #line 127 "prog.pC"
 907 ///////////////////////////////////////////////////////////////////////////////
 908 //
 909 // Pretty printing methods for Stmt
 910 //
 911 ///////////////////////////////////////////////////////////////////////////////
 912 ostream& operator << (ostream& strm__, Stmt  obj__);
 913 PrettyOStream& operator << (PrettyOStream& strm__, Stmt  obj__);
 914
 915 ///////////////////////////////////////////////////////////////////////////////
 916 //
 917 // Interface specification of datatype Type
 918 //
 919 ///////////////////////////////////////////////////////////////////////////////
 920 #line 127 "prog.pC"
 921 ///////////////////////////////////////////////////////////////////////////////
 922 //
 923 // Pretty printing methods for Type
 924 //
 925 ///////////////////////////////////////////////////////////////////////////////
 926 ostream& operator << (ostream& strm__, Type  obj__);
 927 PrettyOStream& operator << (PrettyOStream& strm__, Type  obj__);
 928
 929 ///////////////////////////////////////////////////////////////////////////////
 930 //
 931 // Interface specification of datatype Decl
 932 //
 933 ///////////////////////////////////////////////////////////////////////////////
 934 #line 127 "prog.pC"
 935 ///////////////////////////////////////////////////////////////////////////////
 936 //
 937 // Pretty printing methods for Decl
 938 //
 939 ///////////////////////////////////////////////////////////////////////////////
 940 ostream& operator << (ostream& strm__, Decl  obj__);
 941 PrettyOStream& operator << (PrettyOStream& strm__, Decl  obj__);
 942
 943 ///////////////////////////////////////////////////////////////////////////////
 944 //
 945 // Interface specification of datatype LabeledType
 946 //
 947 ///////////////////////////////////////////////////////////////////////////////
 948 #line 127 "prog.pC"
 949 ///////////////////////////////////////////////////////////////////////////////
 950 //
 951 // Pretty printing methods for LabeledType
 952 //
 953 ///////////////////////////////////////////////////////////////////////////////
 954 ostream& operator << (ostream& strm__, LabeledType  obj__);
 955 PrettyOStream& operator << (PrettyOStream& strm__, LabeledType  obj__);
 956
 957 ///////////////////////////////////////////////////////////////////////////////
 958 //
 959 // Interface specification of datatype List<Type>
 960 //
 961 ///////////////////////////////////////////////////////////////////////////////
 962 #line 127 "prog.pC"
 963 ///////////////////////////////////////////////////////////////////////////////
 964 //
 965 // Pretty printing methods for List<Type>
 966 //
 967 ///////////////////////////////////////////////////////////////////////////////
 968 ostream& operator << (ostream& strm__, a_List<Type> *   obj__);
 969 PrettyOStream& operator << (PrettyOStream& strm__, a_List<Type> *   obj__);
 970
 971 ///////////////////////////////////////////////////////////////////////////////
 972 //
 973 // Interface specification of datatype List<Stmt>
 974 //
 975 ///////////////////////////////////////////////////////////////////////////////
 976 #line 127 "prog.pC"
 977 ///////////////////////////////////////////////////////////////////////////////
 978 //
 979 // Pretty printing methods for List<Stmt>
 980 //
 981 ///////////////////////////////////////////////////////////////////////////////
 982 ostream& operator << (ostream& strm__, a_List<Stmt> *   obj__);
 983 PrettyOStream& operator << (PrettyOStream& strm__, a_List<Stmt> *   obj__);
 984
 985 ///////////////////////////////////////////////////////////////////////////////
 986 //
 987 // Interface specification of datatype List<LabeledType>
 988 //
 989 ///////////////////////////////////////////////////////////////////////////////
 990 #line 127 "prog.pC"
 991 ///////////////////////////////////////////////////////////////////////////////
 992 //
 993 // Pretty printing methods for List<LabeledType>
 994 //
 995 ///////////////////////////////////////////////////////////////////////////////
 996 ostream& operator << (ostream& strm__, a_List<LabeledType> *   obj__);
 997 PrettyOStream& operator << (PrettyOStream& strm__, a_List<LabeledType> *   obj__);
 998
 999 ///////////////////////////////////////////////////////////////////////////////
1000 //
1001 // Interface specification of datatype List<Decl>
1002 //
1003 ///////////////////////////////////////////////////////////////////////////////
1004 #line 127 "prog.pC"
1005 ///////////////////////////////////////////////////////////////////////////////
1006 //
1007 // Pretty printing methods for List<Decl>
1008 //
1009 ///////////////////////////////////////////////////////////////////////////////
1010 ostream& operator << (ostream& strm__, a_List<Decl> *   obj__);
1011 PrettyOStream& operator << (PrettyOStream& strm__, a_List<Decl> *   obj__);
1012
1013 ///////////////////////////////////////////////////////////////////////////////
1014 //
1015 // Instantiation of datatype Exp
1016 //
1017 ///////////////////////////////////////////////////////////////////////////////
1018 #line 127 "prog.pC"
1019 ///////////////////////////////////////////////////////////////////////////////
1020 //
1021 // Pretty printing methods for Exp
1022 //
1023 ///////////////////////////////////////////////////////////////////////////////
1024 ostream& operator << (ostream& strm__, Exp  obj__)
1025 {  PrettyOStream S(strm__); S << obj__; return strm__; }
1026
1027 PrettyOStream& operator << (PrettyOStream& strm__, Exp  obj__)
1028 {
1029    switch (untag(obj__))
1030    {
1031       case 0:
1032          strm__ << _integer(obj__)->integer; // int
1033          break;
1034       case 1:
1035          strm__ << _real(obj__)->real; // double
1036          break;
1037       case 2:
1038          strm__ << "\"";
1039          strm__ << _string(obj__)->string; // char *
1040          strm__ << "\"";
1041          break;
1042       case 3:
1043          strm__ << _boolean(obj__)->boolean; // BOOL
1044          break;
1045       case 4:
1046          strm__ << '(';
1047          strm__ << _binop(obj__)->_2;
1048          strm__ << _binop(obj__)->_1;
1049          strm__ << _binop(obj__)->_3;
1050          strm__ << ')';
1051          break;
1052       case 5:
1053          strm__ << '(';
1054          strm__ << _unaryop(obj__)->_1; // UnaryOp
1055          strm__ << _unaryop(obj__)->_2; // Exp
1056          strm__ << ')';
1057          break;
1058       case 6:
1059          strm__ << _var(obj__)->var; // char const *
1060          break;
1061    }
1062    return strm__;
1063 }
1064
1065
1066
1067 ///////////////////////////////////////////////////////////////////////////////
1068 //
1069 // Instantiation of datatype BOOL
1070 //
1071 ///////////////////////////////////////////////////////////////////////////////
1072 #line 127 "prog.pC"
1073 ///////////////////////////////////////////////////////////////////////////////
1074 //
1075 // Pretty printing methods for BOOL
1076 //
1077 ///////////////////////////////////////////////////////////////////////////////
1078 ostream& operator << (ostream& strm__, BOOL  obj__)
1079 {  PrettyOStream S(strm__); S << obj__; return strm__; }
1080
1081 PrettyOStream& operator << (PrettyOStream& strm__, BOOL  obj__)
1082 {
1083    switch (obj__)
1084    {
1085       case False:
1086          strm__ << "false";
1087          break;
1088       case True:
1089          strm__ << "true";
1090          break;
1091    }
1092    return strm__;
1093 }
1094
1095
1096
1097 ///////////////////////////////////////////////////////////////////////////////
1098 //
1099 // Instantiation of datatype BinOp
1100 //
1101 ///////////////////////////////////////////////////////////////////////////////
1102 #line 127 "prog.pC"
1103 ///////////////////////////////////////////////////////////////////////////////
1104 //
1105 // Pretty printing methods for BinOp
1106 //
1107 ///////////////////////////////////////////////////////////////////////////////
1108 ostream& operator << (ostream& strm__, BinOp  obj__)
1109 {  PrettyOStream S(strm__); S << obj__; return strm__; }
1110
1111 PrettyOStream& operator << (PrettyOStream& strm__, BinOp  obj__)
1112 {
1113    switch (obj__)
1114    {
1115       case add:
1116          strm__ << '+';
1117          break;
1118       case sub:
1119          strm__ << '-';
1120          break;
1121       case mul:
1122          strm__ << '*';
1123          break;
1124       case divide:
1125          strm__ << '/';
1126          break;
1127       case mod:
1128          strm__ << "mod";
1129          break;
1130       case logical_and:
1131          strm__ << "and";
1132          break;
1133       case logical_or:
1134          strm__ << "or";
1135          break;
1136       case eq:
1137          strm__ << '=';
1138          break;
1139       case ge:
1140          strm__ << ">=";
1141          break;
1142       case le:
1143          strm__ << "<=";
1144          break;
1145       case lt:
1146          strm__ << '<';
1147          break;
1148       case gt:
1149          strm__ << '>';
1150          break;
1151       case ne:
1152          strm__ << "<>";
1153          break;
1154    }
1155    return strm__;
1156 }
1157
1158
1159
1160 ///////////////////////////////////////////////////////////////////////////////
1161 //
1162 // Instantiation of datatype UnaryOp
1163 //
1164 ///////////////////////////////////////////////////////////////////////////////
1165 #line 127 "prog.pC"
1166 ///////////////////////////////////////////////////////////////////////////////
1167 //
1168 // Pretty printing methods for UnaryOp
1169 //
1170 ///////////////////////////////////////////////////////////////////////////////
1171 ostream& operator << (ostream& strm__, UnaryOp  obj__)
1172 {  PrettyOStream S(strm__); S << obj__; return strm__; }
1173
1174 PrettyOStream& operator << (PrettyOStream& strm__, UnaryOp  obj__)
1175 {
1176    switch (obj__)
1177    {
1178       case uminus:
1179          strm__ << '-';
1180          break;
1181       case logical_not:
1182          strm__ << "not";
1183          break;
1184    }
1185    return strm__;
1186 }
1187
1188
1189
1190 ///////////////////////////////////////////////////////////////////////////////
1191 //
1192 // Instantiation of datatype Stmt
1193 //
1194 ///////////////////////////////////////////////////////////////////////////////
1195 #line 127 "prog.pC"
1196 ///////////////////////////////////////////////////////////////////////////////
1197 //
1198 // Pretty printing methods for Stmt
1199 //
1200 ///////////////////////////////////////////////////////////////////////////////
1201 ostream& operator << (ostream& strm__, Stmt  obj__)
1202 {  PrettyOStream S(strm__); S << obj__; return strm__; }
1203
1204 PrettyOStream& operator << (PrettyOStream& strm__, Stmt  obj__)
1205 {
1206    switch (untag(obj__))
1207    {
1208       case 0:
1209          strm__ << _assign_stmt(obj__)->_1; // Id
1210          strm__ << ":=";
1211          strm__ << _assign_stmt(obj__)->_2; // Exp
1212          strm__ << ';';
1213          break;
1214       case 1:
1215          strm__ << "while";
1216          strm__ << _while_stmt(obj__)->_1; // Exp
1217          strm__ << "do";
1218          strm__.indent().newline().tab();
1219          strm__ << _while_stmt(obj__)->_2; // Stmt
1220          strm__.unindent().newline().tab();
1221          strm__ << "end while;";
1222          break;
1223       case 2:
1224          strm__ << "if";
1225          strm__ << _if_stmt(obj__)->_1; // Exp
1226          strm__ << "then";
1227          strm__.indent().newline().tab();
1228          strm__ << _if_stmt(obj__)->_2; // Stmt
1229          strm__.unindent().newline().tab();
1230          strm__ << "else";
1231          strm__.indent().newline().tab();
1232          strm__ << _if_stmt(obj__)->_3; // Stmt
1233          strm__.unindent().newline().tab();
1234          strm__ << "endif;";
1235          break;
1236       case 3:
1237          strm__ << "print";
1238          strm__ << _print_stmt(obj__)->print_stmt; // Exp
1239          strm__ << ';';
1240          break;
1241       case 4:
1242          strm__ << "begin";
1243          strm__.indent().newline().tab();
1244          strm__ << _block_stmt(obj__)->_1; // List<Decl>
1245          strm__.newline().tab();
1246          strm__ << _block_stmt(obj__)->_2; // List<Stmt>
1247          strm__.unindent().newline().tab();
1248          strm__ << "end";
1249          break;
1250    }
1251    return strm__;
1252 }
1253
1254
1255
1256 ///////////////////////////////////////////////////////////////////////////////
1257 //
1258 // Instantiation of datatype Type
1259 //
1260 ///////////////////////////////////////////////////////////////////////////////
1261 #line 127 "prog.pC"
1262 ///////////////////////////////////////////////////////////////////////////////
1263 //
1264 // Pretty printing methods for Type
1265 //
1266 ///////////////////////////////////////////////////////////////////////////////
1267 ostream& operator << (ostream& strm__, Type  obj__)
1268 {  PrettyOStream S(strm__); S << obj__; return strm__; }
1269
1270 PrettyOStream& operator << (PrettyOStream& strm__, Type  obj__)
1271 {
1272    switch (untag(obj__))
1273    {
1274       case 0:
1275          strm__ << _primitive_type(obj__)->primitive_type; // char const *
1276          break;
1277       case 1:
1278          strm__ << _pointer_type(obj__)->pointer_type; // Type
1279          strm__ << '^';
1280          break;
1281       case 2:
1282          strm__ << "array";
1283          strm__ << _array_type(obj__)->bound;
1284          strm__ << "of";
1285          strm__ << _array_type(obj__)->element;
1286          break;
1287       case 3:
1288          strm__ << _function_type(obj__)->arg;
1289          strm__ << "->";
1290          strm__ << _function_type(obj__)->ret;
1291          break;
1292       case 4:
1293          strm__ << "tuple_type";
1294          strm__ << '(';
1295          strm__ << _tuple_type(obj__)->tuple_type; // List<Type>
1296          strm__ << ')';
1297          break;
1298       case 5:
1299          strm__ << "record_type";
1300          strm__ << '(';
1301          strm__ << _record_type(obj__)->record_type; // List<LabeledType>
1302          strm__ << ')';
1303          break;
1304    }
1305    return strm__;
1306 }
1307
1308
1309
1310 ///////////////////////////////////////////////////////////////////////////////
1311 //
1312 // Instantiation of datatype Decl
1313 //
1314 ///////////////////////////////////////////////////////////////////////////////
1315 #line 127 "prog.pC"
1316 ///////////////////////////////////////////////////////////////////////////////
1317 //
1318 // Pretty printing methods for Decl
1319 //
1320 ///////////////////////////////////////////////////////////////////////////////
1321 ostream& operator << (ostream& strm__, Decl  obj__)
1322 {  PrettyOStream S(strm__); S << obj__; return strm__; }
1323
1324 PrettyOStream& operator << (PrettyOStream& strm__, Decl  obj__)
1325 {
1326    strm__ << "var";
1327    strm__ << obj__->name;
1328    strm__ << ':';
1329    strm__ << obj__->typ;
1330    strm__ << ';';
1331    return strm__;
1332 }
1333
1334
1335
1336 ///////////////////////////////////////////////////////////////////////////////
1337 //
1338 // Instantiation of datatype LabeledType
1339 //
1340 ///////////////////////////////////////////////////////////////////////////////
1341 #line 127 "prog.pC"
1342 ///////////////////////////////////////////////////////////////////////////////
1343 //
1344 // Pretty printing methods for LabeledType
1345 //
1346 ///////////////////////////////////////////////////////////////////////////////
1347 ostream& operator << (ostream& strm__, LabeledType  obj__)
1348 {  PrettyOStream S(strm__); S << obj__; return strm__; }
1349
1350 PrettyOStream& operator << (PrettyOStream& strm__, LabeledType  obj__)
1351 {
1352    strm__ << obj__->_1; // Id
1353    strm__ << ':';
1354    strm__ << obj__->_2; // Type
1355    return strm__;
1356 }
1357
1358
1359
1360 ///////////////////////////////////////////////////////////////////////////////
1361 //
1362 // Instantiation of datatype List<Type>
1363 //
1364 ///////////////////////////////////////////////////////////////////////////////
1365 #line 127 "prog.pC"
1366 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
1367 template class a_List<Type>;
1368 template a_List<Type> * list_1_(Decl x_1, a_List<Decl> *  x_2);
1369 template a_List<Type> * list_1_(Decl x_list_1_);
1370 template int boxed(const a_List<Type> *);
1371 template int untag(const a_List<Type> *);
1372 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
1373 ///////////////////////////////////////////////////////////////////////////////
1374 //
1375 // Pretty printing methods for List<Type>
1376 //
1377 ///////////////////////////////////////////////////////////////////////////////
1378 ostream& operator << (ostream& strm__, a_List<Type> *   obj__)
1379 {  PrettyOStream S(strm__); S << obj__; return strm__; }
1380
1381 PrettyOStream& operator << (PrettyOStream& strm__, a_List<Type> *   obj__)
1382 {
1383    switch (untag(obj__))
1384    {
1385       case ((int)nil_1_):
1386          strm__ << "";
1387          break;
1388       case 1:
1389          strm__ << obj__->_1; // Type
1390          strm__.newline().tab();
1391          strm__ << obj__->_2; // List<Type>
1392          break;
1393    }
1394    return strm__;
1395 }
1396
1397
1398
1399 ///////////////////////////////////////////////////////////////////////////////
1400 //
1401 // Instantiation of datatype List<Stmt>
1402 //
1403 ///////////////////////////////////////////////////////////////////////////////
1404 #line 127 "prog.pC"
1405 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
1406 template class a_List<Stmt>;
1407 template a_List<Stmt> * list_1_(Type x_1, a_List<Type> *  x_2);
1408 template a_List<Stmt> * list_1_(Type x_list_1_);
1409 template int boxed(const a_List<Stmt> *);
1410 template int untag(const a_List<Stmt> *);
1411 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
1412 ///////////////////////////////////////////////////////////////////////////////
1413 //
1414 // Pretty printing methods for List<Stmt>
1415 //
1416 ///////////////////////////////////////////////////////////////////////////////
1417 ostream& operator << (ostream& strm__, a_List<Stmt> *   obj__)
1418 {  PrettyOStream S(strm__); S << obj__; return strm__; }
1419
1420 PrettyOStream& operator << (PrettyOStream& strm__, a_List<Stmt> *   obj__)
1421 {
1422    switch (untag(obj__))
1423    {
1424       case ((int)nil_1_):
1425          strm__ << "";
1426          break;
1427       case 1:
1428          strm__ << obj__->_1; // Stmt
1429          strm__.newline().tab();
1430          strm__ << obj__->_2; // List<Stmt>
1431          break;
1432    }
1433    return strm__;
1434 }
1435
1436
1437
1438 ///////////////////////////////////////////////////////////////////////////////
1439 //
1440 // Instantiation of datatype List<LabeledType>
1441 //
1442 ///////////////////////////////////////////////////////////////////////////////
1443 #line 127 "prog.pC"
1444 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
1445 template class a_List<LabeledType>;
1446 template a_List<LabeledType> * list_1_(Stmt x_1, a_List<Stmt> *  x_2);
1447 template a_List<LabeledType> * list_1_(Stmt x_list_1_);
1448 template int boxed(const a_List<LabeledType> *);
1449 template int untag(const a_List<LabeledType> *);
1450 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
1451 ///////////////////////////////////////////////////////////////////////////////
1452 //
1453 // Pretty printing methods for List<LabeledType>
1454 //
1455 ///////////////////////////////////////////////////////////////////////////////
1456 ostream& operator << (ostream& strm__, a_List<LabeledType> *   obj__)
1457 {  PrettyOStream S(strm__); S << obj__; return strm__; }
1458
1459 PrettyOStream& operator << (PrettyOStream& strm__, a_List<LabeledType> *   obj__)
1460 {
1461    switch (untag(obj__))
1462    {
1463       case ((int)nil_1_):
1464          strm__ << "";
1465          break;
1466       case 1:
1467          strm__ << obj__->_1; // LabeledType
1468          strm__.newline().tab();
1469          strm__ << obj__->_2; // List<LabeledType>
1470          break;
1471    }
1472    return strm__;
1473 }
1474
1475
1476
1477 ///////////////////////////////////////////////////////////////////////////////
1478 //
1479 // Instantiation of datatype List<Decl>
1480 //
1481 ///////////////////////////////////////////////////////////////////////////////
1482 #line 127 "prog.pC"
1483 #ifdef PROP_EXPLICIT_TEMPLATE_INSTANTIATION
1484 template class a_List<Decl>;
1485 template a_List<Decl> * list_1_(LabeledType x_1, a_List<LabeledType> *  x_2);
1486 template a_List<Decl> * list_1_(LabeledType x_list_1_);
1487 template int boxed(const a_List<Decl> *);
1488 template int untag(const a_List<Decl> *);
1489 #endif /* PROP_EXPLICIT_TEMPLATE_INSTANTIATION */
1490 ///////////////////////////////////////////////////////////////////////////////
1491 //
1492 // Pretty printing methods for List<Decl>
1493 //
1494 ///////////////////////////////////////////////////////////////////////////////
1495 ostream& operator << (ostream& strm__, a_List<Decl> *   obj__)
1496 {  PrettyOStream S(strm__); S << obj__; return strm__; }
1497
1498 PrettyOStream& operator << (PrettyOStream& strm__, a_List<Decl> *   obj__)
1499 {
1500    switch (untag(obj__))
1501    {
1502       case ((int)nil_1_):
1503          strm__ << "";
1504          break;
1505       case 1:
1506          strm__ << obj__->_1; // Decl
1507          strm__.newline().tab();
1508          strm__ << obj__->_2; // List<Decl>
1509          break;
1510    }
1511    return strm__;
1512 }
1513
1514
1515
1516 #line 128 "prog.pC"
1517 #line 128 "prog.pC"
1518
1519
1520 /////////////////////////////////////////////////////////////////////////////
1521 //  Defines the interface of a rewrite class Simplify.
1522 //  All types that are referenced (directly or indirectly) should be
1523 //  declared in the interface.
1524 /////////////////////////////////////////////////////////////////////////////
1525 #line 135 "prog.pC"
1526 #line 144 "prog.pC"
1527 class Simplify : public BURS {
1528 private:
1529    Simplify(const Simplify&);