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 <typename T, class RECV>
 151 struct Any<T *, RECV> : public Base<RECV>
 152 {
 153     const T *argument;
 154
 155     Any(const T *arg) : argument(arg) {}
 156
 157     virtual void
 158     add_arg(RECV &receiver) const
 159     {
 160         receiver.add_arg(argument);
 161     }
 162 };
 163
 164 template <class RECV>
 165 struct Argument : public RefCountingPtr<Base<RECV> >
 166 {
 167     typedef RefCountingPtr<VarArgs::Base<RECV> > Base;
 168
 169     Argument() { }
 170     Argument(const Null &null) { }
 171     template <typename T>
 172     Argument(const T& arg) : Base(new Any<T, RECV>(arg)) { }
 173     template <typename T>
 174     Argument(const T* arg) : Base(new Any<T *, RECV>(arg)) { }
 175
 176     void
 177     add_arg(RECV &receiver) const
 178     {
 179         if (this->data)
 180             this->data->add_arg(receiver);
 181     }
 182 };
 183
 184 template<class RECV>
 185 class List
 186 {
 187   public:
 188     typedef VarArgs::Argument<RECV> Argument;
 189     typedef std::list<Argument> list;
 190     typedef typename list::iterator iterator;
 191     typedef typename list::const_iterator const_iterator;
 192     typedef typename list::size_type size_type;
 193
 194   protected:
 195     list l;
 196
 197   public:
 198     List() {}
 199     List(Argument a01, Argument a02, Argument a03, Argument a04,
 200          Argument a05, Argument a06, Argument a07, Argument a08,
 201          Argument a09, Argument a10, Argument a11, Argument a12,
 202          Argument a13, Argument a14, Argument a15, Argument a16)
 203     {
 204         if (!a01) return;
 205         l.push_back(a01);
 206         if (!a02) return;
 207         l.push_back(a02);
 208         if (!a03) return;
 209         l.push_back(a03);
 210         if (!a04) return;
 211         l.push_back(a04);
 212         if (!a05) return;
 213         l.push_back(a05);
 214         if (!a06) return;
 215         l.push_back(a06);
 216         if (!a07) return;
 217         l.push_back(a07);
 218         if (!a08) return;
 219         l.push_back(a08);
 220         if (!a09) return;
 221         l.push_back(a09);
 222         if (!a10) return;
 223         l.push_back(a10);
 224         if (!a11) return;
 225         l.push_back(a11);
 226         if (!a12) return;
 227         l.push_back(a12);
 228         if (!a13) return;
 229         l.push_back(a13);
 230         if (!a14) return;
 231         l.push_back(a14);
 232         if (!a15) return;
 233         l.push_back(a15);
 234         if (!a16) return;
 235         l.push_back(a16);
 236     }
 237
 238     size_type size() const { return l.size(); }
 239     bool empty() const { return l.empty(); }
 240
 241     iterator begin() { return l.begin(); }
 242     const_iterator begin() const { return l.begin(); }
 243
 244     iterator end() { return l.end(); }
 245     const_iterator end() const { return l.end(); }
 246
 247     void
 248     push_back(const Argument &arg)
 249     {
 250         if (arg)
 251             l.push_back(arg);
 252     }
 253
 254     void
 255     push_front(const Argument &arg)
 256     {
 257         if (arg)
 258             l.push_front(arg);
 259     }
 260
 261     template <typename T>
 262     void
 263     push_back(const T &arg)
 264     {
 265         if (Traits<T>::enabled)
 266             l.push_back(arg);
 267     }
 268
 269     template <typename T>
 270     void
 271     push_front(const T &arg)
 272     {
 273         if (Traits<T>::enabled)
 274             l.push_front(arg);
 275     }
 276
 277     Argument& front() { return l.front(); }
 278     const Argument& front() const { return l.front(); }
 279     Argument& back() { return l.back(); }
 280     const Argument& back() const { return l.back(); }
 281
 282     void erase(iterator position) { return l.erase(position); }
 283     void erase(iterator first, iterator last) { return l.erase(first, last); }
 284     void clear() { return l.clear(); }
 285     void pop_front() { return l.pop_front(); }
 286     void pop_back() { return l.pop_back(); }
 287     void reverse() { l.reverse(); }
 288
 289     /*
 290      * Functions specific to variable arguments
 291      */
 292     void
 293     add_args(RECV &recv) const
 294     {
 295         const_iterator i = l.begin();
 296         const_iterator end = l.end();
 297         while (i != end) {
 298             i->add_arg(recv);
 299             ++i;
 300         }
 301
 302         recv.end_args();
 303     }
 304 };
 305
 306 } // namespace VarArgs
 307
 308 #endif /* __BASE_VARARGS_HH__ */