Attachment 43257 Details for Bug 81763 – reducest testcase

reducest testcase

testcase.i (text/plain), 3.23 KB, created by Manuel Lauss on 2018-01-26 15:52:29 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Manuel Lauss

Created: 2018-01-26 15:52:29 UTC

Size: 3.23 KB

patch

obsolete

>typedef unsigned a;
>typedef unsigned long long c;
>void b(void *);
>namespace d {
>template <typename e, e f> struct g { static constexpr e h = f; };
>template <typename e> struct i : g<bool, __is_trivially_copyable(e)> {};
>template <typename> struct j;
>template <typename e> struct j<e &> { typedef e k; };
>template <typename e> typename j<e>::k l(e &&m) {
>  return static_cast<typename j<e>::k &&>(m);
>}
>} // namespace d
>namespace {
>template <typename n> struct aa { static const bool h = d::i<n>::h; };
>} // namespace
>extern "C" void *memcpy(void *, const void *, a);
>namespace ab {
>class o {
>protected:
>  o(void *, a) {}
>};
>template <typename n> class p : o {
>  using q = n;
>  q r;
>
>protected:
>  p(a s) : o(&r, s) {}
>  using ac = n *;
>  ac ad() {}
>};
>template <typename n, bool> class ae : public p<n> {
>protected:
>  ae(a s) : p<n>(s) {}
>};
>template <typename n> class af : ae<n, aa<n>::h> {
>protected:
>  af(unsigned) : ae<n, aa<n>::h>(sizeof(n)) {}
>  ~af() { b(this->ad()); }
>};
>template <typename n, unsigned t> class ag : public af<n> {
>public:
>  ag() : af<n>(t) {}
>};
>class v {
>  using ac = char *;
>
>public:
>  ac ad();
>  ac ah() {}
>};
>} // namespace ab
>namespace ai {
>using ab::af;
>using ab::ag;
>using ab::v;
>class w {};
>class x;
>namespace aj {
>enum ak { al, am, an, ao, ap };
>}
>template <unsigned aq> class ar : public ag<char, aq> {};
>class as {
>public:
>  aj::ak at();
>  w au() {}
>};
>class av {
>public:
>  void aw(as);
>  void ax(as &ay) {
>    do
>      aw(ay);
>    while (ay.at());
>  }
>  v az(as, af<char> &, bool);
>  struct ba {};
>  ba bb(x *&);
>};
>} // namespace ai
>namespace {
>class bc {
>  typedef c bd;
>  static const bd bf = ~bd();
>  union {
>    c bg;
>    c *bh;
>  } q;
>  unsigned bi;
>  bool bj() { return bi; }
>  c bk() {
>    unsigned bl(bi);
>    c bm = bf >> bl;
>    if (bj())
>      q.bg &= bm;
>    else
>      q.bh[bn()] = bm;
>  }
>  void bo(bc &);
>
>public:
>  bc(bc &that) : bi(that.bi) {
>    if (bj())
>      q.bg = that.q.bg;
>    else
>      bo(that);
>  }
>  bc(bc &&that) : bi(that.bi) { memcpy(&q, &that, sizeof(q)); }
>  c operator=(bc that) {
>    if (bj())
>      delete[] q.bh;
>    memcpy(&q, &that, sizeof(q));
>    bi = that.bi;
>  }
>  c operator=(c bp) {
>    if (bj()) {
>      q.bg = bp;
>      bk();
>    }
>  }
>  void bq() {
>    if (bj()) {
>      q.bg ^= bf;
>      bk();
>    }
>  }
>  unsigned bn();
>};
>bc operator~(bc u) {
>  u.bq();
>  return u;
>}
>} // namespace
>namespace ai {
>class br {
>public:
>  br(char *, char *, w, av &, aj::ak);
>};
>} // namespace ai
>namespace ab {
>class bs : bc {
>  bool bt;
>
>public:
>  bs(bc bu, bool bv) : bc(d::l(bu)), bt(bv) {}
>  bs operator=(c bp) { bc::operator=(bp); }
>  bs operator~() { return bs(~bc(*this), bt); }
>};
>} // namespace ab
>using namespace ai;
>namespace {
>class bw {
>public:
>  ab::bs bx;
>  bw(unsigned);
>};
>} // namespace
>struct by {};
>bool bz(bw &ay, as ca, by &cb, bool cc, av &cd) {
>  switch (ca.at()) {
>  case aj::al: {
>    ar<2> ce;
>    bool cf;
>    v cg = cd.az(ca, ce, cf);
>    br(cg.ad(), cg.ah(), ca.au(), cd, ca.at());
>    return false;
>  }
>  case aj::am:
>    cd.ax(ca);
>    cd.ax(ca);
>    if (bz(ay, ca, cb, cc, cd))
>    case aj::an:
>      ay.bx = ~ay.bx;
>    return false;
>  case aj::ao:
>    ay.bx = ca.at() == aj::ap;
>    cd.ax(ca);
>  }
>}
>av::ba av::bb(x *&) {
>  as ch;
>  unsigned bi;
>  bw ci(bi);
>  by cb;
>  bz(ci, ch, cb, true, *this);
>}

Actions: View

Attachments on bug 81763: 41960 | 43041 | 43242 | 43252 | 43257