service_runtime/nacl_closure.h

   1 /*
   2  * Copyright 2008, Google Inc.
   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:
   8  *
   9  *     * Redistributions of source code must retain the above copyright
  10  * notice, this list of conditions and the following disclaimer.
  11  *     * Redistributions in binary form must reproduce the above
  12  * copyright notice, this list of conditions and the following disclaimer
  13  * in the documentation and/or other materials provided with the
  14  * distribution.
  15  *     * Neither the name of Google Inc. nor the names of its
  16  * contributors may be used to endorse or promote products derived from
  17  * this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 /*
  33  * NaCl service runtime closure.
  34  */
  35
  36 #ifndef NATIVE_CLIENT_SERVICE_RUNTIME_NACL_CLOSURE_H_
  37 #define NATIVE_CLIENT_SERVICE_RUNTIME_NACL_CLOSURE_H_
  38
  39 #include "native_client/service_runtime/nacl_sync.h"
  40
  41 /*
  42  * This file contains declarations for simple closures.  They
  43  * self-delete when run.  The ctors are factory fns, rather than
  44  * placement-new style ctors.  If there is no memory, we immediately
  45  * abort.  The dtor frees.
  46  *
  47  * There are currently subclasses to handle at most 10 arguments.
  48  * Beyond that, wrap the args in a struct and pass a pointer to it!
  49  *
  50  * This should be machine-generated code to allow more args.
  51  *
  52  * Primary deficiency: we use void * as the generic argument type, and
  53  * while it suffices for much, it is neither type-safe nor complete
  54  * (viz, 64-bit types such as int64_t, double, etc won't work).
  55  */
  56
  57 struct NaClClosure;
  58
  59 /* pure virtual */
  60
  61 struct NaClClosureVtbl {
  62   void (*Dtor)(struct NaClClosure *);
  63   void (*Run)(struct NaClClosure *);
  64 };
  65
  66 struct NaClClosure {
  67   struct NaClClosureVtbl const  *vtbl;
  68   struct NaClClosureResult      *res;
  69 };
  70
  71 struct NaClClosure0 {
  72   struct NaClClosure  base;
  73   void                (*fn)(void);
  74 };
  75
  76 struct NaClClosure0 *NaClClosure0Ctor(void  (*fn)(void));
  77 void NaClClosure0Dtor(struct NaClClosure *vself);
  78 void NaClClosure0Run(struct NaClClosure *vself);
  79
  80 struct NaClClosure1 {
  81   struct NaClClosure  base;
  82   void                (*fn)(void *);
  83   void                *arg1;
  84 };
  85
  86 struct NaClClosure1 *NaClClosure1Ctor(void  (*fn)(void *arg1),
  87                                       void  *arg1);
  88 void NaClClosure1Dtor(struct NaClClosure *vself);
  89 void NaClClosure1Run(struct NaClClosure *vself);
  90
  91 struct NaClClosure2 {
  92   struct NaClClosure  base;
  93   void                (*fn)(void *, void *);
  94   void                *arg1;
  95   void                *arg2;
  96 };
  97
  98 struct NaClClosure2 *NaClClosure2Ctor(void  (*fn)(void *arg1,
  99                                                   void *arg2),
 100                                       void  *arg1,
 101                                       void  *arg2);
 102 void NaClClosure2Dtor(struct NaClClosure *self);
 103 void NaClClosure2Run(struct NaClClosure *vself);
 104
 105 struct NaClClosure3 {
 106   struct NaClClosure  base;
 107   void                (*fn)(void *, void *, void *);
 108   void                *arg1;
 109   void                *arg2;
 110   void                *arg3;
 111 };
 112
 113 struct NaClClosure3 *NaClClosure3Ctor(void  (*fn)(void *arg1,
 114                                                   void *arg2,
 115                                                   void *arg3),
 116                                       void  *arg1,
 117                                       void  *arg2,
 118                                       void  *arg3);
 119 void NaClClosure3Dtor(struct NaClClosure *self);
 120 void NaClClosure3Run(struct NaClClosure *vself);
 121
 122 struct NaClClosure4 {
 123   struct NaClClosure  base;
 124   void                (*fn)(void *, void *, void *, void *);
 125   void                *arg1;
 126   void                *arg2;
 127   void                *arg3;
 128   void                *arg4;
 129 };
 130
 131 struct NaClClosure4 *NaClClosure4Ctor(void  (*fn)(void *arg1,
 132                                                   void *arg2,
 133                                                   void *arg3,
 134                                                   void *arg4),
 135                                       void  *arg1,
 136                                       void  *arg2,
 137                                       void  *arg3,
 138                                       void  *arg4);
 139 void NaClClosure4Dtor(struct NaClClosure *self);
 140 void NaClClosure4Run(struct NaClClosure *vself);
 141
 142 struct NaClClosure5 {
 143   struct NaClClosure  base;
 144   void                (*fn)(void *, void *, void *, void *,
 145                             void *);
 146   void                *arg1, *arg2, *arg3, *arg4;
 147   void                *arg5;
 148 };
 149
 150 struct NaClClosure5 *NaClClosure5Ctor(void  (*fn)(void *arg1,
 151                                                   void *arg2,
 152                                                   void *arg3,
 153                                                   void *arg4,
 154                                                   void *arg5),
 155                                       void  *arg1,
 156                                       void  *arg2,
 157                                       void  *arg3,
 158                                       void  *arg4,
 159                                       void  *arg5);
 160 void NaClClosure5Dtor(struct NaClClosure *self);
 161 void NaClClosure5Run(struct NaClClosure *vself);
 162
 163 struct NaClClosure6 {
 164   struct NaClClosure  base;
 165   void                (*fn)(void *, void *, void *, void *,
 166                             void *, void *);
 167   void                *arg1;
 168   void                *arg2;
 169   void                *arg3;
 170   void                *arg4;
 171   void                *arg5;
 172   void                *arg6;
 173 };
 174
 175 struct NaClClosure6 *NaClClosure6Ctor(void  (*fn)(void *arg1,
 176                                                   void *arg2,
 177                                                   void *arg3,
 178                                                   void *arg4,
 179                                                   void *arg5,
 180                                                   void *arg6),
 181                                       void  *arg1,
 182                                       void  *arg2,
 183                                       void  *arg3,
 184                                       void  *arg4,
 185                                       void  *arg5,
 186                                       void  *arg6);
 187 void NaClClosure6Dtor(struct NaClClosure *self);
 188 void NaClClosure6Run(struct NaClClosure *vself);
 189
 190 struct NaClClosure7 {
 191   struct NaClClosure  base;
 192   void                (*fn)(void *, void *, void *, void *,
 193                             void *, void *, void *);
 194   void                *arg1;
 195   void                *arg2;
 196   void                *arg3;
 197   void                *arg4;
 198   void                *arg5;
 199   void                *arg6;
 200   void                *arg7;
 201 };
 202
 203 struct NaClClosure7 *NaClClosure7Ctor(void  (*fn)(void *arg1,
 204                                                   void *arg2,
 205                                                   void *arg3,
 206                                                   void *arg4,
 207                                                   void *arg5,
 208                                                   void *arg6,
 209                                                   void *arg7),
 210                                       void  *arg1,
 211                                       void  *arg2,
 212                                       void  *arg3,
 213                                       void  *arg4,
 214                                       void  *arg5,
 215                                       void  *arg6,
 216                                       void  *arg7);
 217 void NaClClosure7Dtor(struct NaClClosure *self);
 218 void NaClClosure7Run(struct NaClClosure *vself);
 219
 220 struct NaClClosure8 {
 221   struct NaClClosure  base;
 222   void                (*fn)(void *, void *, void *, void *,
 223                             void *, void *, void *, void *);
 224   void                *arg1;
 225   void                *arg2;
 226   void                *arg3;
 227   void                *arg4;
 228   void                *arg5;
 229   void                *arg6;
 230   void                *arg7;
 231   void                *arg8;
 232 };
 233
 234 struct NaClClosure8 *NaClClosure8Ctor(void  (*fn)(void *arg1,
 235                                                   void *arg2,
 236                                                   void *arg3,
 237                                                   void *arg4,
 238                                                   void *arg5,
 239                                                   void *arg6,
 240                                                   void *arg7,
 241                                                   void *arg8),
 242                                       void  *arg1,
 243                                       void  *arg2,
 244                                       void  *arg3,
 245                                       void  *arg4,
 246                                       void  *arg5,
 247                                       void  *arg6,
 248                                       void  *arg7,
 249                                       void  *arg8);
 250 void NaClClosure8Dtor(struct NaClClosure *self);
 251 void NaClClosure8Run(struct NaClClosure *vself);
 252
 253 struct NaClClosure9 {
 254   struct NaClClosure  base;
 255   void                (*fn)(void *, void *, void *, void *,
 256                             void *, void *, void *, void *,
 257                             void *);
 258   void                *arg1;
 259   void                *arg2;
 260   void                *arg3;
 261   void                *arg4;
 262   void                *arg5;
 263   void                *arg6;
 264   void                *arg7;
 265   void                *arg8;
 266   void                *arg9;
 267 };
 268
 269 struct NaClClosure9 *NaClClosure9Ctor(void  (*fn)(void *arg1,
 270                                                   void *arg2,
 271                                                   void *arg3,
 272                                                   void *arg4,
 273                                                   void *arg5,
 274                                                   void *arg6,
 275                                                   void *arg7,
 276                                                   void *arg8,
 277                                                   void *arg9),
 278                                       void  *arg1,
 279                                       void  *arg2,
 280                                       void  *arg3,
 281                                       void  *arg4,
 282                                       void  *arg5,
 283                                       void  *arg6,
 284                                       void  *arg7,
 285                                       void  *arg8,
 286                                       void  *arg9);
 287 void NaClClosure9Dtor(struct NaClClosure *self);
 288 void NaClClosure9Run(struct NaClClosure *vself);
 289
 290 struct NaClClosure10 {
 291   struct NaClClosure  base;
 292   void                (*fn)(void *, void *, void *, void *,
 293                             void *, void *, void *, void *,
 294                             void *, void *);
 295   void                *arg1;
 296   void                *arg2;
 297   void                *arg3;
 298   void                *arg4;
 299   void                *arg5;
 300   void                *arg6;
 301   void                *arg7;
 302   void                *arg8;
 303   void                *arg9;
 304   void                *arg10;
 305 };
 306
 307 struct NaClClosure10 *NaClClosure10Ctor(void  (*fn)(void *arg1,
 308                                                     void *arg2,
 309                                                     void *arg3,
 310                                                     void *arg4,
 311                                                     void *arg5,
 312                                                     void *arg6,
 313                                                     void *arg7,
 314                                                     void *arg8,
 315                                                     void *arg9,
 316                                                     void *arg10),
 317                                       void  *arg1,
 318                                       void  *arg2,
 319                                       void  *arg3,
 320                                       void  *arg4,
 321                                       void  *arg5,
 322                                       void  *arg6,
 323                                       void  *arg7,
 324                                       void  *arg8,
 325                                       void  *arg9,
 326                                       void  *arg10);
 327 void NaClClosure10Dtor(struct NaClClosure *self);
 328 void NaClClosure10Run(struct NaClClosure *vself);
 329
 330 #endif