service_runtime/nacl_closure.c

   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 #include "native_client/service_runtime/nacl_closure.h"
  37
  38 #include "native_client/service_runtime/nacl_log.h"
  39
  40 /*
  41  * This file implements simple closures.  See the header file for
  42  * usage info.
  43  *
  44  * This should be machine-generated code to allow more args.
  45  *
  46  * Primary deficiency: we use void * as the generic argument type, and
  47  * while it suffices for much, it is neither type-safe nor complete
  48  * (viz, 64-bit types such as int64_t, double, etc won't work).
  49  */
  50
  51 static struct NaClClosureVtbl const kNaClClosure0Vtbl = {
  52   NaClClosure0Dtor,
  53   NaClClosure0Run,
  54 };
  55
  56 struct NaClClosure0 *NaClClosure0Ctor(void  (*fn)(void))
  57 {
  58   struct NaClClosure0 *self = malloc(sizeof *self);
  59   if (NULL == self) {
  60     NaClLog(LOG_FATAL, "No memory in NaClClosure0 ctor\n");
  61   }
  62   self->base.vtbl = &kNaClClosure0Vtbl;
  63   self->fn = fn;
  64   return self;
  65 }
  66
  67 void NaClClosure0Dtor(struct NaClClosure *vself)
  68 {
  69   struct NaClClosure0 *self = (struct NaClClosure0 *) vself;
  70   free(self);
  71 }
  72
  73 void NaClClosure0Run(struct NaClClosure *vself)
  74 {
  75   struct NaClClosure0 *self = (struct NaClClosure0 *) vself;
  76   (*self->fn)();
  77   NaClClosure0Dtor(vself);
  78 }
  79
  80 static struct NaClClosureVtbl const kNaClClosure1Vtbl = {
  81   NaClClosure1Dtor,
  82   NaClClosure1Run,
  83 };
  84
  85 struct NaClClosure1 *NaClClosure1Ctor(void  (*fn)(void *),
  86                                       void  *arg1)
  87 {
  88   struct NaClClosure1 *self = malloc(sizeof *self);
  89   if (NULL == self) {
  90     NaClLog(LOG_FATAL, "No memory in NaClClosure1 ctor\n");
  91   }
  92   self->base.vtbl = &kNaClClosure1Vtbl;
  93   self->fn = fn;
  94   self->arg1 = arg1;
  95   return self;
  96 }
  97
  98 void NaClClosure1Dtor(struct NaClClosure *vself)
  99 {
 100   struct NaClClosure1 *self = (struct NaClClosure1 *) vself;
 101   free(self);
 102 }
 103
 104 void NaClClosure1Run(struct NaClClosure *vself)
 105 {
 106   struct NaClClosure1 *self = (struct NaClClosure1 *) vself;
 107   (*self->fn)(self->arg1);
 108   NaClClosure1Dtor(vself);
 109 }
 110
 111 static struct NaClClosureVtbl const kNaClClosure2Vtbl = {
 112   NaClClosure2Dtor,
 113   NaClClosure2Run,
 114 };
 115
 116 struct NaClClosure2 *NaClClosure2Ctor(void  (*fn)(void *, void *),
 117                                       void  *arg1,
 118                                       void  *arg2)
 119 {
 120   struct NaClClosure2 *self = malloc(sizeof *self);
 121   if (NULL == self) {
 122     NaClLog(LOG_FATAL, "No memory in NaClClosure2 ctor\n");
 123   }
 124   self->base.vtbl = &kNaClClosure2Vtbl;
 125   self->fn = fn;
 126   self->arg1 = arg1;
 127   self->arg2 = arg2;
 128   return self;
 129 }
 130
 131 void NaClClosure2Dtor(struct NaClClosure *vself)
 132 {
 133   struct NaClClosure2 *self = (struct NaClClosure2 *) vself;
 134   free(self);
 135 }
 136
 137 void NaClClosure2Run(struct NaClClosure *vself)
 138 {
 139   struct NaClClosure2 *self = (struct NaClClosure2 *) vself;
 140   (*self->fn)(self->arg1, self->arg2);
 141   NaClClosure2Dtor(vself);
 142 }
 143
 144 static struct NaClClosureVtbl const kNaClClosure3Vtbl = {
 145   NaClClosure3Dtor,
 146   NaClClosure3Run,
 147 };
 148
 149 struct NaClClosure3 *NaClClosure3Ctor(void  (*fn)(void *, void *, void *),
 150                                       void  *arg1,
 151                                       void  *arg2,
 152                                       void  *arg3)
 153 {
 154   struct NaClClosure3 *self = malloc(sizeof *self);
 155   if (NULL == self) {
 156     NaClLog(LOG_FATAL, "No memory in NaClClosure3 ctor\n");
 157   }
 158   self->base.vtbl = &kNaClClosure3Vtbl;
 159   self->fn = fn;
 160   self->arg1 = arg1;
 161   self->arg2 = arg2;
 162   self->arg3 = arg3;
 163   return self;
 164 }
 165
 166 void NaClClosure3Dtor(struct NaClClosure *vself)
 167 {
 168   struct NaClClosure3 *self = (struct NaClClosure3 *) vself;
 169   free(self);
 170 }
 171
 172 void NaClClosure3Run(struct NaClClosure *vself)
 173 {
 174   struct NaClClosure3 *self = (struct NaClClosure3 *) vself;
 175   (*self->fn)(self->arg1, self->arg2, self->arg3);
 176   NaClClosure3Dtor(vself);
 177 }
 178
 179 static struct NaClClosureVtbl const kNaClClosure4Vtbl = {
 180   NaClClosure4Dtor,
 181   NaClClosure4Run,
 182 };
 183
 184 struct NaClClosure4 *NaClClosure4Ctor(void  (*fn)(void *, void *,
 185                                                   void *, void *),
 186                                       void  *arg1,
 187                                       void  *arg2,
 188                                       void  *arg3,
 189                                       void  *arg4)
 190 {
 191   struct NaClClosure4 *self = malloc(sizeof *self);
 192   if (NULL == self) {
 193     NaClLog(LOG_FATAL, "No memory in NaClClosure4 ctor\n");
 194   }
 195   self->base.vtbl = &kNaClClosure4Vtbl;
 196   self->fn = fn;
 197   self->arg1 = arg1;
 198   self->arg2 = arg2;
 199   self->arg3 = arg3;
 200   self->arg4 = arg4;
 201   return self;
 202 }
 203
 204 void NaClClosure4Dtor(struct NaClClosure *vself)
 205 {
 206   struct NaClClosure4 *self = (struct NaClClosure4 *) vself;
 207   free(self);
 208 }
 209
 210 void NaClClosure4Run(struct NaClClosure *vself)
 211 {
 212   struct NaClClosure4 *self = (struct NaClClosure4 *) vself;
 213   (*self->fn)(self->arg1, self->arg2, self->arg3, self->arg4);
 214   NaClClosure4Dtor(vself);
 215 }
 216
 217 static struct NaClClosureVtbl const kNaClClosure5Vtbl = {
 218   NaClClosure5Dtor,
 219   NaClClosure5Run,
 220 };
 221
 222 struct NaClClosure5 *NaClClosure5Ctor(void  (*fn)(void *, void *,
 223                                                   void *, void *,
 224                                                   void *),
 225                                       void  *arg1,
 226                                       void  *arg2,
 227                                       void  *arg3,
 228                                       void  *arg4,
 229                                       void  *arg5)
 230 {
 231   struct NaClClosure5 *self = malloc(sizeof *self);
 232   if (NULL == self) {
 233     NaClLog(LOG_FATAL, "No memory in NaClClosure5 ctor\n");
 234   }
 235   self->base.vtbl = &kNaClClosure5Vtbl;
 236   self->fn = fn;
 237   self->arg1 = arg1;
 238   self->arg2 = arg2;
 239   self->arg3 = arg3;
 240   self->arg4 = arg4;
 241   self->arg5 = arg5;
 242   return self;
 243 }
 244
 245 void NaClClosure5Dtor(struct NaClClosure *vself)
 246 {
 247   struct NaClClosure5 *self = (struct NaClClosure5 *) vself;
 248   free(self);
 249 }
 250
 251 void NaClClosure5Run(struct NaClClosure *vself)
 252 {
 253   struct NaClClosure5 *self = (struct NaClClosure5 *) vself;
 254   (*self->fn)(self->arg1, self->arg2, self->arg3, self->arg4,
 255               self->arg5);
 256   NaClClosure5Dtor(vself);
 257 }
 258
 259 static struct NaClClosureVtbl const kNaClClosure6Vtbl = {
 260   NaClClosure6Dtor,
 261   NaClClosure6Run,
 262 };
 263
 264 struct NaClClosure6 *NaClClosure6Ctor(void  (*fn)(void *, void *,
 265                                                   void *, void *,
 266                                                   void *, void *),
 267                                       void  *arg1,
 268                                       void  *arg2,
 269                                       void  *arg3,
 270                                       void  *arg4,
 271                                       void  *arg5,
 272                                       void  *arg6)
 273 {
 274   struct NaClClosure6 *self = malloc(sizeof *self);
 275   if (NULL == self) {
 276     NaClLog(LOG_FATAL, "No memory in NaClClosure6 ctor\n");
 277   }
 278   self->base.vtbl = &kNaClClosure6Vtbl;
 279   self->fn = fn;
 280   self->arg1 = arg1;
 281   self->arg2 = arg2;
 282   self->arg3 = arg3;
 283   self->arg4 = arg4;
 284   self->arg5 = arg5;
 285   self->arg6 = arg6;
 286   return self;
 287 }
 288
 289 void NaClClosure6Dtor(struct NaClClosure *vself)
 290 {
 291   struct NaClClosure6 *self = (struct NaClClosure6 *) vself;
 292   free(self);
 293 }
 294
 295 void NaClClosure6Run(struct NaClClosure *vself)
 296 {
 297   struct NaClClosure6 *self = (struct NaClClosure6 *) vself;
 298   (*self->fn)(self->arg1, self->arg2, self->arg3, self->arg4,
 299               self->arg5, self->arg6);
 300   NaClClosure6Dtor(vself);
 301 }
 302
 303 static struct NaClClosureVtbl const kNaClClosure7Vtbl = {
 304   NaClClosure7Dtor,
 305   NaClClosure7Run,
 306 };
 307
 308 struct NaClClosure7 *NaClClosure7Ctor(void  (*fn)(void *, void *,
 309                                                   void *, void *,
 310                                                   void *, void *,
 311                                                   void *),
 312                                       void  *arg1,
 313                                       void  *arg2,
 314                                       void  *arg3,
 315                                       void  *arg4,
 316                                       void  *arg5,
 317                                       void  *arg6,
 318                                       void  *arg7)
 319 {
 320   struct NaClClosure7 *self = malloc(sizeof *self);
 321   if (NULL == self) {
 322     NaClLog(LOG_FATAL, "No memory in NaClClosure7 ctor\n");
 323   }
 324   self->base.vtbl = &kNaClClosure7Vtbl;
 325   self->fn = fn;
 326   self->arg1 = arg1;
 327   self->arg2 = arg2;
 328   self->arg3 = arg3;
 329   self->arg4 = arg4;
 330   self->arg5 = arg5;
 331   self->arg6 = arg6;
 332   self->arg7 = arg7;
 333   return self;
 334 }
 335
 336 void NaClClosure7Dtor(struct NaClClosure *vself)
 337 {
 338   struct NaClClosure7 *self = (struct NaClClosure7 *) vself;
 339   free(self);
 340 }
 341
 342 void NaClClosure7Run(struct NaClClosure *vself)
 343 {
 344   struct NaClClosure7 *self = (struct NaClClosure7 *) vself;
 345   (*self->fn)(self->arg1, self->arg2, self->arg3, self->arg4,
 346               self->arg5, self->arg6, self->arg7);
 347   NaClClosure7Dtor(vself);
 348 }
 349
 350 static struct NaClClosureVtbl const kNaClClosure8Vtbl = {
 351   NaClClosure8Dtor,
 352   NaClClosure8Run,
 353 };
 354
 355 struct NaClClosure8 *NaClClosure8Ctor(void  (*fn)(void *, void *,
 356                                                   void *, void *,
 357                                                   void *, void *,
 358                                                   void *, void *),
 359                                       void  *arg1,
 360                                       void  *arg2,
 361                                       void  *arg3,
 362                                       void  *arg4,
 363                                       void  *arg5,
 364                                       void  *arg6,
 365                                       void  *arg7,
 366                                       void  *arg8)
 367 {
 368   struct NaClClosure8 *self = malloc(sizeof *self);
 369   if (NULL == self) {
 370     NaClLog(LOG_FATAL, "No memory in NaClClosure8 ctor\n");
 371   }
 372   self->base.vtbl = &kNaClClosure8Vtbl;
 373   self->fn = fn;
 374   self->arg1 = arg1;
 375   self->arg2 = arg2;
 376   self->arg3 = arg3;
 377   self->arg4 = arg4;
 378   self->arg5 = arg5;
 379   self->arg6 = arg6;
 380   self->arg7 = arg7;
 381   self->arg8 = arg8;
 382   return self;
 383 }
 384
 385 void NaClClosure8Dtor(struct NaClClosure *vself)
 386 {
 387   struct NaClClosure8 *self = (struct NaClClosure8 *) vself;
 388   free(self);
 389 }
 390
 391 void NaClClosure8Run(struct NaClClosure *vself)
 392 {
 393   struct NaClClosure8 *self = (struct NaClClosure8 *) vself;
 394   (*self->fn)(self->arg1, self->arg2, self->arg3, self->arg4,
 395               self->arg5, self->arg6, self->arg7, self->arg8);
 396   NaClClosure8Dtor(vself);
 397 }
 398
 399 static struct NaClClosureVtbl const kNaClClosure9Vtbl = {
 400   NaClClosure9Dtor,
 401   NaClClosure9Run,
 402 };
 403
 404 struct NaClClosure9 *NaClClosure9Ctor(void  (*fn)(void *, void *,
 405                                                   void *, void *,
 406                                                   void *, void *,
 407                                                   void *, void *,
 408                                                   void *),
 409                                       void  *arg1,
 410                                       void  *arg2,
 411                                       void  *arg3,
 412                                       void  *arg4,
 413                                       void  *arg5,
 414                                       void  *arg6,
 415                                       void  *arg7,
 416                                       void  *arg8,
 417                                       void  *arg9)
 418 {
 419   struct NaClClosure9 *self = malloc(sizeof *self);
 420   if (NULL == self) {
 421     NaClLog(LOG_FATAL, "No memory in NaClClosure9 ctor\n");
 422   }
 423   self->base.vtbl = &kNaClClosure9Vtbl;
 424   self->fn = fn;
 425   self->arg1 = arg1;
 426   self->arg2 = arg2;
 427   self->arg3 = arg3;
 428   self->arg4 = arg4;
 429   self->arg5 = arg5;
 430   self->arg6 = arg6;
 431   self->arg7 = arg7;
 432   self->arg8 = arg8;
 433   self->arg9 = arg9;
 434   return self;
 435 }
 436
 437 void NaClClosure9Dtor(struct NaClClosure *vself)
 438 {
 439   struct NaClClosure9 *self = (struct NaClClosure9 *) vself;
 440   free(self);
 441 }
 442
 443 void NaClClosure9Run(struct NaClClosure *vself)
 444 {
 445   struct NaClClosure9 *self = (struct NaClClosure9 *) vself;
 446   (*self->fn)(self->arg1, self->arg2, self->arg3, self->arg4,
 447               self->arg5, self->arg6, self->arg7, self->arg8,
 448               self->arg9);
 449   NaClClosure9Dtor(vself);
 450 }
 451
 452 static struct NaClClosureVtbl const kNaClClosure10Vtbl = {
 453   NaClClosure10Dtor,
 454   NaClClosure10Run,
 455 };
 456
 457 struct NaClClosure10 *NaClClosure10Ctor(void  (*fn)(void *, void *,
 458                                                     void *, void *,
 459                                                     void *, void *,
 460                                                     void *, void *,
 461                                                     void *, void *),
 462                                         void  *arg1,
 463                                         void  *arg2,
 464                                         void  *arg3,
 465                                         void  *arg4,
 466                                         void  *arg5,
 467                                         void  *arg6,
 468                                         void  *arg7,
 469                                         void  *arg8,
 470                                         void  *arg9,
 471                                         void  *arg10)
 472 {
 473   struct NaClClosure10 *self = malloc(sizeof *self);
 474   if (NULL == self) {
 475     NaClLog(LOG_FATAL, "No memory in NaClClosure10 ctor\n");
 476   }
 477   self->base.vtbl = &kNaClClosure10Vtbl;
 478   self->fn = fn;
 479   self->arg1 = arg1;
 480   self->arg2 = arg2;
 481   self->arg3 = arg3;
 482   self->arg4 = arg4;
 483   self->arg5 = arg5;
 484   self->arg6 = arg6;
 485   self->arg7 = arg7;
 486   self->arg8 = arg8;
 487   self->arg9 = arg9;
 488   self->arg10 = arg10;
 489   return self;
 490 }
 491
 492 void NaClClosure10Dtor(struct NaClClosure *vself)
 493 {
 494   struct NaClClosure10 *self = (struct NaClClosure10 *) vself;
 495   free(self);
 496 }
 497
 498 void NaClClosure10Run(struct NaClClosure *vself)
 499 {
 500   struct NaClClosure10 *self = (struct NaClClosure10 *) vself;
 501   (*self->fn)(self->arg1, self->arg2, self->arg3, self->arg4,
 502               self->arg5, self->arg6, self->arg7, self->arg8,
 503               self->arg9, self->arg10);
 504   NaClClosure10Dtor(vself);
 505 }