src/base/varargs.hh

   1 /*
   2  * Copyright (c) 2006 The Regents of The University of Michigan
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met: redistributions of source code must retain the above copyright
   8  * notice, this list of conditions and the following disclaimer;
   9  * redistributions in binary form must reproduce the above copyright
  10  * notice, this list of conditions and the following disclaimer in the
  11  * documentation and/or other materials provided with the distribution;
  12  * neither the name of the copyright holders nor the names of its
  13  * contributors may be used to endorse or promote products derived from
  14  * this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * Authors: Nathan Binkert
  29  */
  30
  31 #ifndef __BASE_VARARGS_HH__
  32 #define __BASE_VARARGS_HH__
  33
  34 #include "base/refcnt.hh"
  35
  36 #define VARARGS_DECLARATION(receiver)                  \
  37     VarArgs::Argument<receiver> a01 = VarArgs::Null(), \
  38     VarArgs::Argument<receiver> a02 = VarArgs::Null(), \
  39     VarArgs::Argument<receiver> a03 = VarArgs::Null(), \
  40     VarArgs::Argument<receiver> a04 = VarArgs::Null(), \
  41     VarArgs::Argument<receiver> a05 = VarArgs::Null(), \
  42     VarArgs::Argument<receiver> a06 = VarArgs::Null(), \
  43     VarArgs::Argument<receiver> a07 = VarArgs::Null(), \
  44     VarArgs::Argument<receiver> a08 = VarArgs::Null(), \
  45     VarArgs::Argument<receiver> a09 = VarArgs::Null(), \
  46     VarArgs::Argument<receiver> a10 = VarArgs::Null(), \
  47     VarArgs::Argument<receiver> a11 = VarArgs::Null(), \
  48     VarArgs::Argument<receiver> a12 = VarArgs::Null(), \
  49     VarArgs::Argument<receiver> a13 = VarArgs::Null(), \
  50     VarArgs::Argument<receiver> a14 = VarArgs::Null(), \
  51     VarArgs::Argument<receiver> a15 = VarArgs::Null(), \
  52     VarArgs::Argument<receiver> a16 = VarArgs::Null()
  53
  54 #define VARARGS_DEFINITION(receiver) \
  55     VarArgs::Argument<receiver> a01, \
  56     VarArgs::Argument<receiver> a02, \
  57     VarArgs::Argument<receiver> a03, \
  58     VarArgs::Argument<receiver> a04, \
  59     VarArgs::Argument<receiver> a05, \
  60     VarArgs::Argument<receiver> a06, \
  61     VarArgs::Argument<receiver> a07, \
  62     VarArgs::Argument<receiver> a08, \
  63     VarArgs::Argument<receiver> a09, \
  64     VarArgs::Argument<receiver> a10, \
  65     VarArgs::Argument<receiver> a11, \
  66     VarArgs::Argument<receiver> a12, \
  67     VarArgs::Argument<receiver> a13, \
  68     VarArgs::Argument<receiver> a14, \
  69     VarArgs::Argument<receiver> a15, \
  70     VarArgs::Argument<receiver> a16
  71
  72 #define VARARGS_ALLARGS                     \
  73     a01, a02, a03, a04, a05, a06, a07, a08, \
  74     a09, a10, a11, a12, a13, a14, a15, a16
  75
  76 #define VARARGS_ADDARGS(receiver) do { \
  77     do {                           \
  78         if (!a01) break;           \
  79         a01.add_arg(receiver);     \
  80         if (!a02) break;           \
  81         a02.add_arg(receiver);     \
  82         if (!a03) break;           \
  83         a03.add_arg(receiver);     \
  84         if (!a04) break;           \
  85         a04.add_arg(receiver);     \
  86         if (!a05) break;           \
  87         a05.add_arg(receiver);     \
  88         if (!a06) break;           \
  89         a06.add_arg(receiver);     \
  90         if (!a07) break;           \
  91         a07.add_arg(receiver);     \
  92         if (!a08) break;           \
  93         a08.add_arg(receiver);     \
  94         if (!a09) break;           \
  95         a09.add_arg(receiver);     \
  96         if (!a10) break;           \
  97         a10.add_arg(receiver);     \
  98         if (!a11) break;           \
  99         a11.add_arg(receiver);     \
 100         if (!a12) break;           \
 101         a12.add_arg(receiver);     \
 102         if (!a13) break;           \
 103         a13.add_arg(receiver);     \
 104         if (!a14) break;           \
 105         a14.add_arg(receiver);     \
 106         if (!a15) break;           \
 107         a15.add_arg(receiver);     \
 108         if (!a16) break;           \
 109         a16.add_arg(receiver);     \
 110     } while (0);                   \
 111     receiver.end_args();           \
 112 } while (0)
 113
 114 namespace VarArgs {
 115
 116 struct Null {};
 117
 118 template <typename T>
 119 struct Traits
 120 {
 121     enum { enabled = true };
 122 };
 123
 124 template <>
 125 struct Traits<Null>
 126 {
 127     enum { enabled = false };
 128 };
 129
 130 template <class RECV>
 131 struct Base : public RefCounted
 132 {
 133     virtual void add_arg(RECV &receiver) const = 0;
 134 };
 135
 136 template <typename T, class RECV>
 137 struct Any : public Base<RECV>
 138 {
 139     const T &argument;
 140
 141     Any(const T &arg) : argument(arg) {}
 142
 143     virtual void
 144     add_arg(RECV &receiver) const
 145     {
 146         receiver.add_arg(argument);
 147     }
 148 };
 149
 150 template <class RECV>
 151 struct Argument : public RefCountingPtr<Base<RECV> >
 152 {
 153     typedef RefCountingPtr<Base<RECV> > Base;
 154
 155     Argument() { }
 156     Argument(const Null &null) { }
 157     template <typename T>
 158     Argument(const T& arg) : Base(new Any<T, RECV>(arg)) { }
 159
 160     void
 161     add_arg(RECV &receiver) const
 162     {
 163         if (this->data)
 164             this->data->add_arg(receiver);
 165     }
 166 };
 167
 168 template<class RECV>
 169 class List
 170 {
 171   public:
 172     typedef Argument<RECV> Argument;
 173     typedef std::list<Argument> list;
 174     typedef typename list::iterator iterator;
 175     typedef typename list::const_iterator const_iterator;
 176     typedef typename list::size_type size_type;
 177
 178   protected:
 179     list l;
 180
 181   public:
 182     List() {}
 183     List(Argument a01, Argument a02, Argument a03, Argument a04,
 184          Argument a05, Argument a06, Argument a07, Argument a08,
 185          Argument a09, Argument a10, Argument a11, Argument a12,
 186          Argument a13, Argument a14, Argument a15, Argument a16)
 187     {
 188         if (!a01) return;
 189         l.push_back(a01);
 190         if (!a02) return;
 191         l.push_back(a02);
 192         if (!a03) return;
 193         l.push_back(a03);
 194         if (!a04) return;
 195         l.push_back(a04);
 196         if (!a05) return;
 197         l.push_back(a05);
 198         if (!a06) return;
 199         l.push_back(a06);
 200         if (!a07) return;
 201         l.push_back(a07);
 202         if (!a08) return;
 203         l.push_back(a08);
 204         if (!a09) return;
 205         l.push_back(a09);
 206         if (!a10) return;
 207         l.push_back(a10);
 208         if (!a11) return;
 209         l.push_back(a11);
 210         if (!a12) return;
 211         l.push_back(a12);
 212         if (!a13) return;
 213         l.push_back(a13);
 214         if (!a14) return;
 215         l.push_back(a14);
 216         if (!a15) return;
 217         l.push_back(a15);
 218         if (!a16) return;
 219         l.push_back(a16);
 220     }
 221
 222     size_type size() const { return l.size(); }
 223     bool empty() const { return l.empty(); }
 224
 225     iterator begin() { return l.begin(); }
 226     const_iterator begin() const { return l.begin(); }
 227
 228     iterator end() { return l.end(); }
 229     const_iterator end() const { return l.end(); }
 230
 231     void
 232     push_back(const Argument &arg)
 233     {
 234         if (arg)
 235             l.push_back(arg);
 236     }
 237
 238     void
 239     push_front(const Argument &arg)
 240     {
 241         if (arg)
 242             l.push_front(arg);
 243     }
 244
 245     template <typename T>
 246     void
 247     push_back(const T &arg)
 248     {
 249         if (Traits<T>::enabled)
 250             l.push_back(arg);
 251     }
 252
 253     template <typename T>
 254     void
 255     push_front(const T &arg)
 256     {
 257         if (Traits<T>::enabled)
 258             l.push_front(arg);
 259     }
 260
 261     Argument& front() { return l.front(); }
 262     const Argument& front() const { return l.front(); }
 263     Argument& back() { return l.back(); }
 264     const Argument& back() const { return l.back(); }
 265
 266     void erase(iterator position) { return l.erase(position); }
 267     void erase(iterator first, iterator last) { return l.erase(first, last); }
 268     void clear() { return l.clear(); }
 269     void pop_front() { return l.pop_front(); }
 270     void pop_back() { return l.pop_back(); }
 271     void reverse() { l.reverse(); }
 272
 273     /*
 274      * Functions specific to variable arguments
 275      */
 276     void
 277     add_args(RECV &recv) const
 278     {
 279         const_iterator i = l.begin();
 280         const_iterator end = l.end();
 281         while (i != end) {
 282             i->add_arg(recv);
 283             ++i;
 284         }
 285
 286         recv.end_args();
 287     }
 288 };
 289
 290 /* end namespace VarArgs */ }
 291
 292 #endif /* __BASE_VARARGS_HH__ */