app/setl-pe/setl-ast.cc

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //  This file is generated automatically using Prop (version 2.2.9),
   3 //  last updated on Jan 21, 1997.
   4 //  The original source file is "setl-ast.pcc".
   5 ///////////////////////////////////////////////////////////////////////////////
   6
   7 #define PROP_GARBAGE_COLLECTION_USED
   8 #define PROP_PRINTER_USED
   9 #include <propdefs.h>
  10 #line 1 "setl-ast.pcc"
  11 #include "setl-ast.h"
  12
  13 #line 3 "setl-ast.pcc"
  14 #line 3 "setl-ast.pcc"
  15 ///////////////////////////////////////////////////////////////////////////////
  16 // GC tracing method for base class of Exp
  17 ///////////////////////////////////////////////////////////////////////////////
  18 void a_Exp::trace(GC * _gc_)
  19 {
  20 }
  21
  22 a_Exp::~a_Exp() {}
  23 ///////////////////////////////////////////////////////////////////////////////
  24 // GC tracing method for Exp::IDexp Id
  25 ///////////////////////////////////////////////////////////////////////////////
  26 void Exp_IDexp::trace(GC * _gc_)
  27 {
  28    // Id
  29 }
  30
  31 inline Exp_IDexp::Exp_IDexp (Id _xIDexp)
  32    : a_Exp(a_Exp::tag_IDexp), IDexp(_xIDexp) {}
  33 a_Exp * IDexp (Id _xIDexp)
  34    { return new Exp_IDexp (_xIDexp); }
  35 Exp_IDexp::~Exp_IDexp() {}
  36 ///////////////////////////////////////////////////////////////////////////////
  37 // GC tracing method for Exp::LITexp Literal
  38 ///////////////////////////////////////////////////////////////////////////////
  39 void Exp_LITexp::trace(GC * _gc_)
  40 {
  41    LITexp = (Literal )_gc_->trace(LITexp); // Literal
  42 }
  43
  44 inline Exp_LITexp::Exp_LITexp (Literal _xLITexp)
  45    : a_Exp(a_Exp::tag_LITexp), LITexp(_xLITexp) {}
  46 a_Exp * LITexp (Literal _xLITexp)
  47    { return new Exp_LITexp (_xLITexp); }
  48 Exp_LITexp::~Exp_LITexp() {}
  49 ///////////////////////////////////////////////////////////////////////////////
  50 // GC tracing method for Exp::APPexp (Exp, Exp)
  51 ///////////////////////////////////////////////////////////////////////////////
  52 void Exp_APPexp::trace(GC * _gc_)
  53 {
  54    _1 = (Exp )_gc_->trace(_1); // Exp
  55    _2 = (Exp )_gc_->trace(_2); // Exp
  56 }
  57
  58 inline Exp_APPexp::Exp_APPexp (Exp _x1, Exp _x2)
  59    : a_Exp(a_Exp::tag_APPexp), _1(_x1), _2(_x2) {}
  60 a_Exp * APPexp (Exp _x1, Exp _x2)
  61    { return new Exp_APPexp (_x1, _x2); }
  62 Exp_APPexp::~Exp_APPexp() {}
  63 ///////////////////////////////////////////////////////////////////////////////
  64 // GC tracing method for Exp::TUPLEexp Exps
  65 ///////////////////////////////////////////////////////////////////////////////
  66 void Exp_TUPLEexp::trace(GC * _gc_)
  67 {
  68    TUPLEexp = (List(Exp) )_gc_->trace(TUPLEexp); // Exps
  69 }
  70
  71 inline Exp_TUPLEexp::Exp_TUPLEexp (Exps _xTUPLEexp)
  72    : a_Exp(a_Exp::tag_TUPLEexp), TUPLEexp(_xTUPLEexp) {}
  73 a_Exp * TUPLEexp (Exps _xTUPLEexp)
  74    { return new Exp_TUPLEexp (_xTUPLEexp); }
  75 Exp_TUPLEexp::~Exp_TUPLEexp() {}
  76 ///////////////////////////////////////////////////////////////////////////////
  77 // GC tracing method for Exp::RECORDexp LabeledExps
  78 ///////////////////////////////////////////////////////////////////////////////
  79 void Exp_RECORDexp::trace(GC * _gc_)
  80 {
  81    RECORDexp = (List(LabeledExp) )_gc_->trace(RECORDexp); // LabeledExps
  82 }
  83
  84 inline Exp_RECORDexp::Exp_RECORDexp (LabeledExps _xRECORDexp)
  85    : a_Exp(a_Exp::tag_RECORDexp), RECORDexp(_xRECORDexp) {}
  86 a_Exp * RECORDexp (LabeledExps _xRECORDexp)
  87    { return new Exp_RECORDexp (_xRECORDexp); }
  88 Exp_RECORDexp::~Exp_RECORDexp() {}
  89 ///////////////////////////////////////////////////////////////////////////////
  90 // GC tracing method for Exp::SETexp Exps
  91 ///////////////////////////////////////////////////////////////////////////////
  92 void Exp_SETexp::trace(GC * _gc_)
  93 {
  94    SETexp = (List(Exp) )_gc_->trace(SETexp); // Exps
  95 }
  96
  97 inline Exp_SETexp::Exp_SETexp (Exps _xSETexp)
  98    : a_Exp(a_Exp::tag_SETexp), SETexp(_xSETexp) {}
  99 a_Exp * SETexp (Exps _xSETexp)
 100    { return new Exp_SETexp (_xSETexp); }
 101 Exp_SETexp::~Exp_SETexp() {}
 102 ///////////////////////////////////////////////////////////////////////////////
 103 // GC tracing method for Exp::CASEexp (Exp, Exps)
 104 ///////////////////////////////////////////////////////////////////////////////
 105 void Exp_CASEexp::trace(GC * _gc_)
 106 {
 107    _1 = (Exp )_gc_->trace(_1); // Exp
 108    _2 = (List(Exp) )_gc_->trace(_2); // Exps
 109 }
 110
 111 inline Exp_CASEexp::Exp_CASEexp (Exp _x1, Exps _x2)
 112    : a_Exp(a_Exp::tag_CASEexp), _1(_x1), _2(_x2) {}
 113 a_Exp * CASEexp (Exp _x1, Exps _x2)
 114    { return new Exp_CASEexp (_x1, _x2); }
 115 Exp_CASEexp::~Exp_CASEexp() {}
 116 ///////////////////////////////////////////////////////////////////////////////
 117 // GC tracing method for Exp::IFexp (Exp, Exp, Exp)
 118 ///////////////////////////////////////////////////////////////////////////////
 119 void Exp_IFexp::trace(GC * _gc_)
 120 {
 121    _1 = (Exp )_gc_->trace(_1); // Exp
 122    _2 = (Exp )_gc_->trace(_2); // Exp
 123    _3 = (Exp )_gc_->trace(_3); // Exp
 124 }
 125
 126 inline Exp_IFexp::Exp_IFexp (Exp _x1, Exp _x2, Exp _x3)
 127    : a_Exp(a_Exp::tag_IFexp), _1(_x1), _2(_x2), _3(_x3) {}
 128 a_Exp * IFexp (Exp _x1, Exp _x2, Exp _x3)
 129    { return new Exp_IFexp (_x1, _x2, _x3); }
 130 Exp_IFexp::~Exp_IFexp() {}
 131 ///////////////////////////////////////////////////////////////////////////////
 132 // GC tracing method for Exp::WHILEexp (Exp, Exp)
 133 ///////////////////////////////////////////////////////////////////////////////
 134 void Exp_WHILEexp::trace(GC * _gc_)
 135 {
 136    _1 = (Exp )_gc_->trace(_1); // Exp
 137    _2 = (Exp )_gc_->trace(_2); // Exp
 138 }
 139
 140 inline Exp_WHILEexp::Exp_WHILEexp (Exp _x1, Exp _x2)
 141    : a_Exp(a_Exp::tag_WHILEexp), _1(_x1), _2(_x2) {}
 142 a_Exp * WHILEexp (Exp _x1, Exp _x2)
 143    { return new Exp_WHILEexp (_x1, _x2); }
 144 Exp_WHILEexp::~Exp_WHILEexp() {}
 145 ///////////////////////////////////////////////////////////////////////////////
 146 // GC tracing method for Exp::SEQexp Exps
 147 ///////////////////////////////////////////////////////////////////////////////
 148 void Exp_SEQexp::trace(GC * _gc_)
 149 {
 150    SEQexp = (List(Exp) )_gc_->trace(SEQexp); // Exps
 151 }
 152
 153 inline Exp_SEQexp::Exp_SEQexp (Exps _xSEQexp)
 154    : a_Exp(a_Exp::tag_SEQexp), SEQexp(_xSEQexp) {}
 155 a_Exp * SEQexp (Exps _xSEQexp)
 156    { return new Exp_SEQexp (_xSEQexp); }
 157 Exp_SEQexp::~Exp_SEQexp() {}
 158 ///////////////////////////////////////////////////////////////////////////////
 159 // GC tracing method for Exp::LETexp (Decls, Exp)
 160 ///////////////////////////////////////////////////////////////////////////////
 161 void Exp_LETexp::trace(GC * _gc_)
 162 {
 163    _1 = (List(Decl) )_gc_->trace(_1); // Decls
 164    _2 = (Exp )_gc_->trace(_2); // Exp
 165 }
 166
 167 inline Exp_LETexp::Exp_LETexp (Decls _x1, Exp _x2)
 168    : a_Exp(a_Exp::tag_LETexp), _1(_x1), _2(_x2) {}
 169 a_Exp * LETexp (Decls _x1, Exp _x2)
 170    { return new Exp_LETexp (_x1, _x2); }
 171 Exp_LETexp::~Exp_LETexp() {}
 172 ///////////////////////////////////////////////////////////////////////////////
 173 // GC tracing method for Exp::PRIMexp Prim
 174 ///////////////////////////////////////////////////////////////////////////////
 175 void Exp_PRIMexp::trace(GC * _gc_)
 176 {
 177    // Prim
 178 }
 179
 180 inline Exp_PRIMexp::Exp_PRIMexp (Prim _xPRIMexp)
 181    : a_Exp(a_Exp::tag_PRIMexp), PRIMexp(_xPRIMexp) {}
 182 a_Exp * PRIMexp (Prim _xPRIMexp)
 183    { return new Exp_PRIMexp (_xPRIMexp); }
 184 Exp_PRIMexp::~Exp_PRIMexp() {}
 185 ///////////////////////////////////////////////////////////////////////////////
 186 // GC tracing method for base class of LabeledExp
 187 ///////////////////////////////////////////////////////////////////////////////
 188 void a_LabeledExp::trace(GC * _gc_)
 189 {
 190    // Id
 191    exp = (Exp )_gc_->trace(exp); // Exp
 192 }
 193
 194 inline a_LabeledExp::a_LabeledExp (Id _xid, Exp _xexp)
 195    : id(_xid), exp(_xexp) {}
 196 a_LabeledExp * LABELEDexp (Id _xid, Exp _xexp)
 197    { return new a_LabeledExp (_xid, _xexp); }
 198 a_LabeledExp::~a_LabeledExp() {}
 199 ///////////////////////////////////////////////////////////////////////////////
 200 // GC tracing method for base class of Decl
 201 ///////////////////////////////////////////////////////////////////////////////
 202 void a_Decl::trace(GC * _gc_)
 203 {
 204 }
 205
 206 a_Decl::~a_Decl() {}
 207 ///////////////////////////////////////////////////////////////////////////////
 208 // GC tracing method for Decl::TYPEdecl (Id, Ids, Ty)
 209 ///////////////////////////////////////////////////////////////////////////////
 210 void Decl_TYPEdecl::trace(GC * _gc_)
 211 {
 212    // Id
 213    _2 = (List(Id) )_gc_->trace(_2); // Ids
 214    _3 = (Ty )_gc_->trace(_3); // Ty
 215 }
 216
 217 inline Decl_TYPEdecl::Decl_TYPEdecl (Id _x1, Ids _x2, Ty _x3)
 218    : a_Decl(a_Decl::tag_TYPEdecl), _1(_x1), _2(_x2), _3(_x3) {}
 219 a_Decl * TYPEdecl (Id _x1, Ids _x2, Ty _x3)
 220    { return new Decl_TYPEdecl (_x1, _x2, _x3); }
 221 Decl_TYPEdecl::~Decl_TYPEdecl() {}
 222 ///////////////////////////////////////////////////////////////////////////////
 223 // GC tracing method for Decl::DATATYPEdecl (Id, Ids, Terms)
 224 ///////////////////////////////////////////////////////////////////////////////
 225 void Decl_DATATYPEdecl::trace(GC * _gc_)
 226 {
 227    // Id
 228    _2 = (List(Id) )_gc_->trace(_2); // Ids
 229    _3 = (List(Term) )_gc_->trace(_3); // Terms
 230 }
 231
 232 inline Decl_DATATYPEdecl::Decl_DATATYPEdecl (Id _x1, Ids _x2, Terms _x3)
 233    : a_Decl(a_Decl::tag_DATATYPEdecl), _1(_x1), _2(_x2), _3(_x3) {}
 234 a_Decl * DATATYPEdecl (Id _x1, Ids _x2, Terms _x3)
 235    { return new Decl_DATATYPEdecl (_x1, _x2, _x3); }
 236 Decl_DATATYPEdecl::~Decl_DATATYPEdecl() {}
 237 ///////////////////////////////////////////////////////////////////////////////
 238 // GC tracing method for base class of Literal
 239 ///////////////////////////////////////////////////////////////////////////////
 240 void a_Literal::trace(GC * _gc_)
 241 {
 242 }
 243
 244 a_Literal::~a_Literal() {}
 245 ///////////////////////////////////////////////////////////////////////////////
 246 // GC tracing method for Literal::INTlit int
 247 ///////////////////////////////////////////////////////////////////////////////
 248 void Literal_INTlit::trace(GC * _gc_)
 249 {
 250    // int
 251 }
 252
 253 inline Literal_INTlit::Literal_INTlit (int _xINTlit)
 254    : a_Literal(a_Literal::tag_INTlit), INTlit(_xINTlit) {}
 255 a_Literal * INTlit (int _xINTlit)
 256    { return new Literal_INTlit (_xINTlit); }
 257 Literal_INTlit::~Literal_INTlit() {}
 258 ///////////////////////////////////////////////////////////////////////////////
 259 // GC tracing method for Literal::REALlit double
 260 ///////////////////////////////////////////////////////////////////////////////
 261 void Literal_REALlit::trace(GC * _gc_)
 262 {
 263    // double
 264 }
 265
 266 inline Literal_REALlit::Literal_REALlit (double _xREALlit)
 267    : a_Literal(a_Literal::tag_REALlit), REALlit(_xREALlit) {}
 268 a_Literal * REALlit (double _xREALlit)
 269    { return new Literal_REALlit (_xREALlit); }
 270 Literal_REALlit::~Literal_REALlit() {}
 271 ///////////////////////////////////////////////////////////////////////////////
 272 // GC tracing method for Literal::STRINGlit char const *
 273 ///////////////////////////////////////////////////////////////////////////////
 274 void Literal_STRINGlit::trace(GC * _gc_)
 275 {
 276    // char const *
 277 }
 278
 279 inline Literal_STRINGlit::Literal_STRINGlit (char const * _xSTRINGlit)
 280    : a_Literal(a_Literal::tag_STRINGlit), STRINGlit(_xSTRINGlit) {}
 281 a_Literal * STRINGlit (char const * _xSTRINGlit)
 282    { return new Literal_STRINGlit (_xSTRINGlit); }
 283 Literal_STRINGlit::~Literal_STRINGlit() {}
 284 ///////////////////////////////////////////////////////////////////////////////
 285 // GC tracing method for Literal::CHARlit char
 286 ///////////////////////////////////////////////////////////////////////////////
 287 void Literal_CHARlit::trace(GC * _gc_)
 288 {
 289    // char
 290 }
 291
 292 inline Literal_CHARlit::Literal_CHARlit (char _xCHARlit)
 293    : a_Literal(a_Literal::tag_CHARlit), CHARlit(_xCHARlit) {}
 294 a_Literal * CHARlit (char _xCHARlit)
 295    { return new Literal_CHARlit (_xCHARlit); }
 296 Literal_CHARlit::~Literal_CHARlit() {}
 297 ///////////////////////////////////////////////////////////////////////////////
 298 // GC tracing method for base class of Term
 299 ///////////////////////////////////////////////////////////////////////////////
 300 void a_Term::trace(GC * _gc_)
 301 {
 302    // Id
 303    _2 = (Ty )_gc_->trace(_2); // Ty
 304 }
 305
 306 inline a_Term::a_Term (Id _x1, Ty _x2)
 307    : _1(_x1), _2(_x2) {}
 308 a_Term * TERM (Id _x1, Ty _x2)
 309    { return new a_Term (_x1, _x2); }
 310 a_Term::~a_Term() {}
 311 ///////////////////////////////////////////////////////////////////////////////
 312 // GC tracing method for base class of Ty
 313 ///////////////////////////////////////////////////////////////////////////////
 314 void a_Ty::trace(GC * _gc_)
 315 {
 316    VARty = (Ty )_gc_->trace(VARty); // Ty
 317 }
 318
 319 inline a_Ty::a_Ty (Ty _xVARty)
 320    : VARty(_xVARty) {}
 321 a_Ty * VARty (Ty _xVARty)
 322    { return new a_Ty (_xVARty); }
 323 a_Ty::~a_Ty() {}
 324 ///////////////////////////////////////////////////////////////////////////////
 325 // GC tracing method for base class of List<Id>
 326 ///////////////////////////////////////////////////////////////////////////////
 327 void a_List<Id>::trace(GC * _gc_)
 328 {
 329    // Id
 330    _2 = (List(Id) )_gc_->trace(_2); // List<Id>
 331 }
 332
 333 ///////////////////////////////////////////////////////////////////////////////
 334 // GC tracing method for base class of List<Exp>
 335 ///////////////////////////////////////////////////////////////////////////////
 336 void a_List<Exp>::trace(GC * _gc_)
 337 {
 338    _1 = (Exp )_gc_->trace(_1); // Exp
 339    _2 = (List(Exp) )_gc_->trace(_2); // List<Exp>
 340 }
 341
 342 ///////////////////////////////////////////////////////////////////////////////
 343 // GC tracing method for base class of List<LabeledExp>
 344 ///////////////////////////////////////////////////////////////////////////////
 345 void a_List<LabeledExp>::trace(GC * _gc_)
 346 {
 347    _1 = (LabeledExp )_gc_->trace(_1); // LabeledExp
 348    _2 = (List(LabeledExp) )_gc_->trace(_2); // List<LabeledExp>
 349 }
 350
 351 ///////////////////////////////////////////////////////////////////////////////
 352 // GC tracing method for base class of List<Decl>
 353 ///////////////////////////////////////////////////////////////////////////////
 354 void a_List<Decl>::trace(GC * _gc_)
 355 {
 356    _1 = (Decl )_gc_->trace(_1); // Decl
 357    _2 = (List(Decl) )_gc_->trace(_2); // List<Decl>
 358 }
 359
 360 ///////////////////////////////////////////////////////////////////////////////
 361 // GC tracing method for base class of List<Literal>
 362 ///////////////////////////////////////////////////////////////////////////////
 363 void a_List<Literal>::trace(GC * _gc_)
 364 {
 365    _1 = (Literal )_gc_->trace(_1); // Literal
 366    _2 = (List(Literal) )_gc_->trace(_2); // List<Literal>
 367 }
 368
 369 ///////////////////////////////////////////////////////////////////////////////
 370 // GC tracing method for base class of List<Term>
 371 ///////////////////////////////////////////////////////////////////////////////
 372 void a_List<Term>::trace(GC * _gc_)
 373 {
 374    _1 = (Term )_gc_->trace(_1); // Term
 375    _2 = (List(Term) )_gc_->trace(_2); // List<Term>
 376 }
 377
 378 ///////////////////////////////////////////////////////////////////////////////
 379 // GC tracing method for base class of List<Ty>
 380 ///////////////////////////////////////////////////////////////////////////////
 381 void a_List<Ty>::trace(GC * _gc_)
 382 {
 383    _1 = (Ty )_gc_->trace(_1); // Ty
 384    _2 = (List(Ty) )_gc_->trace(_2); // List<Ty>
 385 }
 386
 387 #line 7 "setl-ast.pcc"
 388 #line 7 "setl-ast.pcc"
 389
 390 #line 8 "setl-ast.pcc"
 391 /*
 392 ------------------------------- Statistics -------------------------------
 393 Merge matching rules         = yes
 394 Number of DFA nodes merged   = 0
 395 Number of ifs generated      = 0
 396 Number of switches generated = 0
 397 Number of labels             = 0
 398 Number of gotos              = 0
 399 Adaptive matching            = enabled
 400 Fast string matching         = enabled
 401 Inline downcasts             = enabled
 402 --------------------------------------------------------------------------
 403 */