prop-src/simple.cc

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //  This file is generated automatically using Prop (version 2.3.7),
   3 //  last updated on Oct 21, 2008.
   4 //  The original source file is "simple.pcc".
   5 ///////////////////////////////////////////////////////////////////////////////
   6
   7 #line 1 "simple.pcc"
   8 #include <iostream>
   9 #include <memory>
  10
  11 #line 4 "simple.pcc"
  12 #line 9 "simple.pcc"
  13 ///////////////////////////////////////////////////////////////////////////////
  14 //
  15 // Forward class definition for Exp
  16 //
  17 ///////////////////////////////////////////////////////////////////////////////
  18 #ifndef datatype_Exp_defined
  19 #define datatype_Exp_defined
  20    class a_Exp;
  21    typedef a_Exp * Exp;
  22 #endif
  23
  24 ///////////////////////////////////////////////////////////////////////////////
  25 //
  26 // Base class for datatype Exp
  27 //
  28 ///////////////////////////////////////////////////////////////////////////////
  29 class a_Exp {
  30 public:
  31    enum Tag_Exp {
  32       tag_INT = 0, tag_ADD = 1, tag_SUB = 2,
  33       tag_MUL = 3, tag_DIV = 4
  34    };
  35
  36 public:
  37    const Tag_Exp tag__; // variant tag
  38 protected:
  39    inline a_Exp(Tag_Exp t__) : tag__(t__) {}
  40 public:
  41 };
  42 inline int boxed(const a_Exp *) { return 1; }
  43 inline int untag(const a_Exp * x) { return x->tag__; }
  44 ///////////////////////////////////////////////////////////////////////////////
  45 //
  46 // Class for datatype constructor Exp::INT
  47 //
  48 ///////////////////////////////////////////////////////////////////////////////
  49 class Exp_INT : public a_Exp {
  50 public:
  51 #line 4 "simple.pcc"
  52    int INT;
  53    inline Exp_INT (int x_INT)
  54     : a_Exp(tag_INT), INT(x_INT)
  55    {
  56    }
  57 };
  58
  59 ///////////////////////////////////////////////////////////////////////////////
  60 //
  61 // Class for datatype constructor Exp::ADD
  62 //
  63 ///////////////////////////////////////////////////////////////////////////////
  64 class Exp_ADD : public a_Exp {
  65 public:
  66 #line 5 "simple.pcc"
  67    Exp _1; Exp _2;
  68    inline Exp_ADD (Exp x_1, Exp x_2)
  69     : a_Exp(tag_ADD), _1(x_1), _2(x_2)
  70    {
  71    }
  72 };
  73
  74 ///////////////////////////////////////////////////////////////////////////////
  75 //
  76 // Class for datatype constructor Exp::SUB
  77 //
  78 ///////////////////////////////////////////////////////////////////////////////
  79 class Exp_SUB : public a_Exp {
  80 public:
  81 #line 6 "simple.pcc"
  82    Exp _1; Exp _2;
  83    inline Exp_SUB (Exp x_1, Exp x_2)
  84     : a_Exp(tag_SUB), _1(x_1), _2(x_2)
  85    {
  86    }
  87 };
  88
  89 ///////////////////////////////////////////////////////////////////////////////
  90 //
  91 // Class for datatype constructor Exp::MUL
  92 //
  93 ///////////////////////////////////////////////////////////////////////////////
  94 class Exp_MUL : public a_Exp {
  95 public:
  96 #line 7 "simple.pcc"
  97    Exp _1; Exp _2;
  98    inline Exp_MUL (Exp x_1, Exp x_2)
  99     : a_Exp(tag_MUL), _1(x_1), _2(x_2)
 100    {
 101    }
 102 };
 103
 104 ///////////////////////////////////////////////////////////////////////////////
 105 //
 106 // Class for datatype constructor Exp::DIV
 107 //
 108 ///////////////////////////////////////////////////////////////////////////////
 109 class Exp_DIV : public a_Exp {
 110 public:
 111 #line 8 "simple.pcc"
 112    Exp _1; Exp _2;
 113    inline Exp_DIV (Exp x_1, Exp x_2)
 114     : a_Exp(tag_DIV), _1(x_1), _2(x_2)
 115    {
 116    }
 117 };
 118
 119 ///////////////////////////////////////////////////////////////////////////////
 120 //
 121 // Datatype constructor functions for Exp
 122 //
 123 ///////////////////////////////////////////////////////////////////////////////
 124 inline a_Exp * INT (int x_INT)
 125 {
 126    return new Exp_INT (x_INT);
 127 }
 128 inline a_Exp * ADD (Exp x_1, Exp x_2)
 129 {
 130    return new Exp_ADD (x_1, x_2);
 131 }
 132 inline a_Exp * SUB (Exp x_1, Exp x_2)
 133 {
 134    return new Exp_SUB (x_1, x_2);
 135 }
 136 inline a_Exp * MUL (Exp x_1, Exp x_2)
 137 {
 138    return new Exp_MUL (x_1, x_2);
 139 }
 140 inline a_Exp * DIV (Exp x_1, Exp x_2)
 141 {
 142    return new Exp_DIV (x_1, x_2);
 143 }
 144 ///////////////////////////////////////////////////////////////////////////////
 145 //
 146 // Downcasting functions for Exp
 147 //
 148 ///////////////////////////////////////////////////////////////////////////////
 149 inline Exp_INT * _INT(const a_Exp * _x_) { return (Exp_INT *)_x_; }
 150 inline Exp_ADD * _ADD(const a_Exp * _x_) { return (Exp_ADD *)_x_; }
 151 inline Exp_SUB * _SUB(const a_Exp * _x_) { return (Exp_SUB *)_x_; }
 152 inline Exp_MUL * _MUL(const a_Exp * _x_) { return (Exp_MUL *)_x_; }
 153 inline Exp_DIV * _DIV(const a_Exp * _x_) { return (Exp_DIV *)_x_; }
 154
 155 #line 9 "simple.pcc"
 156 #line 9 "simple.pcc"
 157
 158
 159 #line 11 "simple.pcc"
 160 #line 11 "simple.pcc"
 161 ///////////////////////////////////////////////////////////////////////////////
 162 //
 163 // Forward class definition for Q
 164 //
 165 ///////////////////////////////////////////////////////////////////////////////
 166 #ifndef datatype_Q_defined
 167 #define datatype_Q_defined
 168    class a_Q;
 169    typedef a_Q * Q;
 170 #endif
 171
 172 ///////////////////////////////////////////////////////////////////////////////
 173 //
 174 // Base class for datatype Q
 175 //
 176 ///////////////////////////////////////////////////////////////////////////////
 177 class a_Q {
 178 public:
 179    enum Tag_Q {
 180       tag_Expr = 0, tag_Str = 1
 181    };
 182
 183 public:
 184    const Tag_Q tag__; // variant tag
 185 protected:
 186    inline a_Q(Tag_Q t__) : tag__(t__) {}
 187 public:
 188 };
 189 inline int boxed(const a_Q *) { return 1; }
 190 inline int untag(const a_Q * x) { return x->tag__; }
 191 ///////////////////////////////////////////////////////////////////////////////
 192 //
 193 // Class for datatype constructor Q::Expr
 194 //
 195 ///////////////////////////////////////////////////////////////////////////////
 196 class Q_Expr : public a_Q {
 197 public:
 198 #line 11 "simple.pcc"
 199    Exp Expr;
 200    inline Q_Expr (Exp x_Expr)
 201     : a_Q(tag_Expr), Expr(x_Expr)
 202    {
 203    }
 204 };
 205
 206 ///////////////////////////////////////////////////////////////////////////////
 207 //
 208 // Class for datatype constructor Q::Str
 209 //
 210 ///////////////////////////////////////////////////////////////////////////////
 211 class Q_Str : public a_Q {
 212 public:
 213 #line 11 "simple.pcc"
 214    std::string Str;
 215    inline Q_Str (std::string x_Str)
 216     : a_Q(tag_Str), Str(x_Str)
 217    {
 218    }
 219 };
 220
 221 ///////////////////////////////////////////////////////////////////////////////
 222 //
 223 // Datatype constructor functions for Q
 224 //
 225 ///////////////////////////////////////////////////////////////////////////////
 226 inline a_Q * Expr (Exp x_Expr)
 227 {
 228    return new Q_Expr (x_Expr);
 229 }
 230 inline a_Q * Str (std::string x_Str)
 231 {
 232    return new Q_Str (x_Str);
 233 }
 234 ///////////////////////////////////////////////////////////////////////////////
 235 //
 236 // Downcasting functions for Q
 237 //
 238 ///////////////////////////////////////////////////////////////////////////////
 239 inline Q_Expr * _Expr(const a_Q * _x_) { return (Q_Expr *)_x_; }
 240 inline Q_Str * _Str(const a_Q * _x_) { return (Q_Str *)_x_; }
 241
 242 #line 11 "simple.pcc"
 243 #line 11 "simple.pcc"
 244
 245
 246 int main()
 247 {
 248   std::auto_ptr<a_Q> q(Expr(ADD(INT(2),INT(3))));
 249
 250
 251 #line 17 "simple.pcc"
 252 #line 19 "simple.pcc"
 253 {
 254    Q _V1 = q.get();
 255    if (_V1->tag__) {
 256
 257 #line 19 "simple.pcc"
 258      std::cout << _Str(_V1)->Str << std::endl;
 259 #line 19 "simple.pcc"
 260    } else {
 261
 262 #line 18 "simple.pcc"
 263      std::cout << "expr" << std::endl;
 264 #line 18 "simple.pcc"
 265    }
 266 }
 267 #line 20 "simple.pcc"
 268 #line 20 "simple.pcc"
 269
 270
 271   return 0;
 272 }
 273 #line 24 "simple.pcc"
 274 /*
 275 ------------------------------- Statistics -------------------------------
 276 Merge matching rules         = yes
 277 Number of DFA nodes merged   = 0
 278 Number of ifs generated      = 1
 279 Number of switches generated = 0
 280 Number of labels             = 0
 281 Number of gotos              = 0
 282 Adaptive matching            = disabled
 283 Fast string matching         = disabled
 284 Inline downcasts             = disabled
 285 --------------------------------------------------------------------------
 286 */