dev-games/glkloader/files/glkloader-0.3.2-r4-cache-function-pointers.patch

   1 Source: dleverton
   2 Upstream: previous version submitted
   3 Reason: cache function pointers returned by dlsym() instead of looking
   4         them up each time; gives a noticeable speed increase
   5
   6 --- glkloader-0.3.2/generate_glkfuncs.pl~       2013-07-08 15:05:49.000000000 +0100
   7 +++ glkloader-0.3.2/generate_glkfuncs.pl        2013-07-08 15:06:07.000000000 +0100
   8 @@ -307,7 +307,9 @@
   9
  10     print OUT_FILE "$ret_type $name(", createArgList (@arg_list), ")\n";
  11     print OUT_FILE "{\n";
  12 -   print OUT_FILE "    $ret_type (*funcPtr)(", createArgList (@arg_list), ");\n";
  13 +   print OUT_FILE "    static $ret_type (*funcPtr)(", createArgList (@arg_list), ");\n";
  14 +   print OUT_FILE "\n";
  15 +   print OUT_FILE "    if (! funcPtr) {\n";
  16     print OUT_FILE "    char * errBuf = NULL;\n";
  17     print OUT_FILE "\n";
  18     print OUT_FILE "    funcPtr = loadSymbol(gGlkLib, \"$name\", &errBuf);\n";
  19 @@ -315,6 +317,7 @@
  20     print OUT_FILE "        fprintf(stderr, \"%s\\n\", errBuf);\n";
  21     print OUT_FILE "        exit(1);\n";
  22     print OUT_FILE "    }\n";
  23 +   print OUT_FILE "    }\n";
  24     print OUT_FILE "\n";
  25     if ($ret_type eq "void")
  26     {
  27 --- glkloader-0.3.2/blorbfuncs.c~       2013-07-08 15:05:56.000000000 +0100
  28 +++ glkloader-0.3.2/blorbfuncs.c        2013-07-08 15:06:07.000000000 +0100
  29 @@ -46,7 +46,9 @@
  30
  31  giblorb_err_t giblorb_set_resource_map(strid_t file)
  32  {
  33 -    giblorb_err_t (*funcPtr)(strid_t file);
  34 +    static giblorb_err_t (*funcPtr)(strid_t file);
  35 +
  36 +    if (! funcPtr) {
  37      char * errBuf = NULL;
  38
  39      funcPtr = loadSymbol(gGlkLib, "giblorb_set_resource_map", &errBuf);
  40 @@ -54,13 +56,16 @@
  41          fprintf(stderr, "%s\n", errBuf);
  42          exit(1);
  43      }
  44 +    }
  45
  46      return (*funcPtr)(file);
  47  }
  48
  49  giblorb_map_t *giblorb_get_resource_map(void)
  50  {
  51 -    giblorb_map_t * (*funcPtr)(void);
  52 +    static giblorb_map_t * (*funcPtr)(void);
  53 +
  54 +    if (! funcPtr) {
  55      char * errBuf = NULL;
  56
  57      funcPtr = loadSymbol(gGlkLib, "giblorb_get_resource_map", &errBuf);
  58 @@ -68,13 +73,16 @@
  59          fprintf(stderr, "%s\n", errBuf);
  60          exit(1);
  61      }
  62 +    }
  63
  64      return (*funcPtr)();
  65  }
  66
  67  giblorb_err_t giblorb_create_map(strid_t file, giblorb_map_t **newmap)
  68  {
  69 -    giblorb_err_t (*funcPtr)(strid_t file, giblorb_map_t **newmap);
  70 +    static giblorb_err_t (*funcPtr)(strid_t file, giblorb_map_t **newmap);
  71 +
  72 +    if (! funcPtr) {
  73      char * errBuf = NULL;
  74
  75      funcPtr = loadSymbol(gGlkLib, "giblorb_create_map", &errBuf);
  76 @@ -82,13 +90,16 @@
  77          fprintf(stderr, "%s\n", errBuf);
  78          exit(1);
  79      }
  80 +    }
  81
  82      return (*funcPtr)(file, newmap);
  83  }
  84
  85  giblorb_err_t giblorb_destroy_map(giblorb_map_t *map)
  86  {
  87 -    giblorb_err_t (*funcPtr)(giblorb_map_t *map);
  88 +    static giblorb_err_t (*funcPtr)(giblorb_map_t *map);
  89 +
  90 +    if (! funcPtr) {
  91      char * errBuf = NULL;
  92
  93      funcPtr = loadSymbol(gGlkLib, "giblorb_destroy_map", &errBuf);
  94 @@ -96,6 +107,7 @@
  95          fprintf(stderr, "%s\n", errBuf);
  96          exit(1);
  97      }
  98 +    }
  99
 100      return (*funcPtr)(map);
 101  }
 102 @@ -103,8 +115,10 @@
 103  giblorb_err_t giblorb_load_chunk_by_type(giblorb_map_t *map,
 104      glui32 method, giblorb_result_t *res, glui32 chunktype, glui32 count)
 105  {
 106 -    giblorb_err_t (*funcPtr)(giblorb_map_t *map,
 107 +    static giblorb_err_t (*funcPtr)(giblorb_map_t *map,
 108          glui32 method, giblorb_result_t *res, glui32 chunktype, glui32 count);
 109 +
 110 +    if (! funcPtr) {
 111      char * errBuf = NULL;
 112
 113      funcPtr = loadSymbol(gGlkLib, "giblorb_load_chunk_by_type", &errBuf);
 114 @@ -112,6 +126,7 @@
 115          fprintf(stderr, "%s\n", errBuf);
 116          exit(1);
 117      }
 118 +    }
 119
 120      return (*funcPtr)(map, method, res, chunktype, count);
 121  }
 122 @@ -119,8 +134,10 @@
 123  giblorb_err_t giblorb_load_chunk_by_number(giblorb_map_t *map,
 124      glui32 method, giblorb_result_t *res, glui32 chunknum)
 125  {
 126 -    giblorb_err_t  (*funcPtr)(giblorb_map_t *map,
 127 +    static giblorb_err_t  (*funcPtr)(giblorb_map_t *map,
 128          glui32 method, giblorb_result_t *res, glui32 chunknum);
 129 +
 130 +    if (! funcPtr) {
 131      char * errBuf = NULL;
 132
 133      funcPtr = loadSymbol(gGlkLib, "giblorb_load_chunk_by_number", &errBuf);
 134 @@ -128,13 +145,16 @@
 135          fprintf(stderr, "%s\n", errBuf);
 136          exit(1);
 137      }
 138 +    }
 139
 140      return (*funcPtr)(map, method, res, chunknum);
 141  }
 142
 143  giblorb_err_t giblorb_unload_chunk(giblorb_map_t *map, glui32 chunknum)
 144  {
 145 -    giblorb_err_t  (*funcPtr)(giblorb_map_t *map, glui32 chunknum);
 146 +    static giblorb_err_t  (*funcPtr)(giblorb_map_t *map, glui32 chunknum);
 147 +
 148 +    if (! funcPtr) {
 149      char * errBuf = NULL;
 150
 151      funcPtr = loadSymbol(gGlkLib, "giblorb_unload_chunk", &errBuf);
 152 @@ -142,6 +162,7 @@
 153          fprintf(stderr, "%s\n", errBuf);
 154          exit(1);
 155      }
 156 +    }
 157
 158      return (*funcPtr)(map, chunknum);
 159  }
 160 @@ -149,8 +170,10 @@
 161  giblorb_err_t giblorb_load_resource(giblorb_map_t *map,
 162      glui32 method, giblorb_result_t *res, glui32 usage, glui32 resnum)
 163  {
 164 -    giblorb_err_t  (*funcPtr)(giblorb_map_t *map,
 165 +    static giblorb_err_t  (*funcPtr)(giblorb_map_t *map,
 166          glui32 method, giblorb_result_t *res, glui32 usage, glui32 resnum);
 167 +
 168 +    if (! funcPtr) {
 169      char * errBuf = NULL;
 170
 171      funcPtr = loadSymbol(gGlkLib, "giblorb_load_resource", &errBuf);
 172 @@ -158,6 +181,7 @@
 173          fprintf(stderr, "%s\n", errBuf);
 174          exit(1);
 175      }
 176 +    }
 177
 178      return (*funcPtr)(map, method, res, usage, resnum);
 179  }
 180 @@ -165,8 +189,10 @@
 181  giblorb_err_t giblorb_count_resources(giblorb_map_t *map,
 182      glui32 usage, glui32 *num, glui32 *min, glui32 *max)
 183  {
 184 -    giblorb_err_t  (*funcPtr)(giblorb_map_t *map,
 185 +    static giblorb_err_t  (*funcPtr)(giblorb_map_t *map,
 186          glui32 usage, glui32 *num, glui32 *min, glui32 *max);
 187 +
 188 +    if (! funcPtr) {
 189      char * errBuf = NULL;
 190
 191      funcPtr = loadSymbol(gGlkLib, "giblorb_count_resources", &errBuf);
 192 @@ -174,6 +200,7 @@
 193          fprintf(stderr, "%s\n", errBuf);
 194          exit(1);
 195      }
 196 +    }
 197
 198      return (*funcPtr)(map, usage, num, min, max);
 199  }
 200 --- glkloader-0.3.2/dispafuncs.c~       2013-07-08 15:05:56.000000000 +0100
 201 +++ glkloader-0.3.2/dispafuncs.c        2013-07-08 15:06:07.000000000 +0100
 202 @@ -48,9 +48,11 @@
 203      gidispatch_rock_t (*regi)(void *obj, glui32 objclass),
 204      void (*unregi)(void *obj, glui32 objclass, gidispatch_rock_t objrock))
 205  {
 206 -    void (*funcPtr)(
 207 +    static void (*funcPtr)(
 208          gidispatch_rock_t (*regi)(void *obj, glui32 objclass),
 209          void (*unregi)(void *obj, glui32 objclass, gidispatch_rock_t objrock));
 210 +
 211 +    if (! funcPtr) {
 212      char * errBuf = NULL;
 213
 214      funcPtr = loadSymbol(gGlkLib, "gidispatch_set_object_registry", &errBuf);
 215 @@ -58,13 +60,16 @@
 216          fprintf(stderr, "%s\n", errBuf);
 217          exit(1);
 218      }
 219 +    }
 220
 221      (*funcPtr)(regi, unregi);
 222  }
 223
 224  gidispatch_rock_t gidispatch_get_objrock(void *obj, glui32 objclass)
 225  {
 226 -    gidispatch_rock_t (*funcPtr)(void *obj, glui32 objclass);
 227 +    static gidispatch_rock_t (*funcPtr)(void *obj, glui32 objclass);
 228 +
 229 +    if (! funcPtr) {
 230      char * errBuf = NULL;
 231
 232      funcPtr = loadSymbol(gGlkLib, "gidispatch_get_objrock", &errBuf);
 233 @@ -72,6 +77,7 @@
 234          fprintf(stderr, "%s\n", errBuf);
 235          exit(1);
 236      }
 237 +    }
 238
 239      return (*funcPtr)(obj, objclass);
 240  }
 241 @@ -81,10 +87,12 @@
 242      void (*unregi)(void *array, glui32 len, char *typecode,
 243          gidispatch_rock_t objrock))
 244  {
 245 -    void (*funcPtr)(
 246 +    static void (*funcPtr)(
 247          gidispatch_rock_t (*regi)(void *array, glui32 len, char *typecode),
 248          void (*unregi)(void *array, glui32 len, char *typecode,
 249              gidispatch_rock_t objrock));
 250 +
 251 +    if (! funcPtr) {
 252      char * errBuf = NULL;
 253
 254      funcPtr = loadSymbol(gGlkLib, "gidispatch_set_retained_registry", &errBuf);
 255 @@ -92,13 +100,16 @@
 256          fprintf(stderr, "%s\n", errBuf);
 257          exit(1);
 258      }
 259 +    }
 260
 261      return (*funcPtr)(regi, unregi);
 262  }
 263
 264  void gidispatch_call(glui32 funcnum, glui32 numargs, gluniversal_t *arglist)
 265  {
 266 -    void (*funcPtr)(glui32 funcnum, glui32 numargs, gluniversal_t *arglist);
 267 +    static void (*funcPtr)(glui32 funcnum, glui32 numargs, gluniversal_t *arglist);
 268 +
 269 +    if (! funcPtr) {
 270      char * errBuf = NULL;
 271
 272      funcPtr = loadSymbol(gGlkLib, "gidispatch_call", &errBuf);
 273 @@ -106,13 +117,16 @@
 274          fprintf(stderr, "%s\n", errBuf);
 275          exit(1);
 276      }
 277 +    }
 278
 279      return (*funcPtr)(funcnum, numargs, arglist);
 280  }
 281
 282  char *gidispatch_prototype(glui32 funcnum)
 283  {
 284 -    char * (*funcPtr)(glui32 funcnum);
 285 +    static char * (*funcPtr)(glui32 funcnum);
 286 +
 287 +    if (! funcPtr) {
 288      char * errBuf = NULL;
 289
 290      funcPtr = loadSymbol(gGlkLib, "gidispatch_prototype", &errBuf);
 291 @@ -120,13 +134,16 @@
 292          fprintf(stderr, "%s\n", errBuf);
 293          exit(1);
 294      }
 295 +    }
 296
 297      return (*funcPtr)(funcnum);
 298  }
 299
 300  glui32 gidispatch_count_classes(void)
 301  {
 302 -    glui32 (*funcPtr)(void);
 303 +    static glui32 (*funcPtr)(void);
 304 +
 305 +    if (! funcPtr) {
 306      char * errBuf = NULL;
 307
 308      funcPtr = loadSymbol(gGlkLib, "gidispatch_count_classes", &errBuf);
 309 @@ -134,13 +151,16 @@
 310          fprintf(stderr, "%s\n", errBuf);
 311          exit(1);
 312      }
 313 +    }
 314
 315      return (*funcPtr)();
 316  }
 317
 318  gidispatch_intconst_t *gidispatch_get_class(glui32 index)
 319  {
 320 -    gidispatch_intconst_t * (*funcPtr)(glui32 index);
 321 +    static gidispatch_intconst_t * (*funcPtr)(glui32 index);
 322 +
 323 +    if (! funcPtr) {
 324      char * errBuf = NULL;
 325
 326      funcPtr = loadSymbol(gGlkLib, "gidispatch_get_class", &errBuf);
 327 @@ -148,13 +168,16 @@
 328          fprintf(stderr, "%s\n", errBuf);
 329          exit(1);
 330      }
 331 +    }
 332
 333      return (*funcPtr)(index);
 334  }
 335
 336  glui32 gidispatch_count_intconst(void)
 337  {
 338 -    glui32 (*funcPtr)(void);
 339 +    static glui32 (*funcPtr)(void);
 340 +
 341 +    if (! funcPtr) {
 342      char * errBuf = NULL;
 343
 344      funcPtr = loadSymbol(gGlkLib, "gidispatch_count_intconst", &errBuf);
 345 @@ -162,13 +185,16 @@
 346          fprintf(stderr, "%s\n", errBuf);
 347          exit(1);
 348      }
 349 +    }
 350
 351      return (*funcPtr)();
 352  }
 353
 354  gidispatch_intconst_t *gidispatch_get_intconst(glui32 index)
 355  {
 356 -    gidispatch_intconst_t * (*funcPtr)(glui32 index);
 357 +    static gidispatch_intconst_t * (*funcPtr)(glui32 index);
 358 +
 359 +    if (! funcPtr) {
 360      char * errBuf = NULL;
 361
 362      funcPtr = loadSymbol(gGlkLib, "gidispatch_get_intconst", &errBuf);
 363 @@ -176,13 +202,16 @@
 364          fprintf(stderr, "%s\n", errBuf);
 365          exit(1);
 366      }
 367 +    }
 368
 369      return (*funcPtr)(index);
 370  }
 371
 372  glui32 gidispatch_count_functions(void)
 373  {
 374 -    glui32 (*funcPtr)(void);
 375 +    static glui32 (*funcPtr)(void);
 376 +
 377 +    if (! funcPtr) {
 378      char * errBuf = NULL;
 379
 380      funcPtr = loadSymbol(gGlkLib, "gidispatch_count_functions", &errBuf);
 381 @@ -190,13 +219,16 @@
 382          fprintf(stderr, "%s\n", errBuf);
 383          exit(1);
 384      }
 385 +    }
 386
 387      return (*funcPtr)();
 388  }
 389
 390  gidispatch_function_t *gidispatch_get_function(glui32 index)
 391  {
 392 -    gidispatch_function_t * (*funcPtr)(glui32 index);
 393 +    static gidispatch_function_t * (*funcPtr)(glui32 index);
 394 +
 395 +    if (! funcPtr) {
 396      char * errBuf = NULL;
 397
 398      funcPtr = loadSymbol(gGlkLib, "gidispatch_get_function", &errBuf);
 399 @@ -204,13 +236,16 @@
 400          fprintf(stderr, "%s\n", errBuf);
 401          exit(1);
 402      }
 403 +    }
 404
 405      return (*funcPtr)(index);
 406  }
 407
 408  gidispatch_function_t *gidispatch_get_function_by_id(glui32 id)
 409  {
 410 -    gidispatch_function_t * (*funcPtr)(glui32 id);
 411 +    static gidispatch_function_t * (*funcPtr)(glui32 id);
 412 +
 413 +    if (! funcPtr) {
 414      char * errBuf = NULL;
 415
 416      funcPtr = loadSymbol(gGlkLib, "gidispatch_get_function_by_id", &errBuf);
 417 @@ -218,6 +253,7 @@
 418          fprintf(stderr, "%s\n", errBuf);
 419          exit(1);
 420      }
 421 +    }
 422
 423      return (*funcPtr)(id);
 424  }
 425 --- glkloader-0.3.2/unixfuncs.c~        2013-07-08 15:05:41.000000000 +0100
 426 +++ glkloader-0.3.2/unixfuncs.c 2013-07-08 15:09:09.000000000 +0100
 427 @@ -47,7 +47,9 @@
 428  strid_t glkunix_stream_open_pathname(char *pathname, glui32 textmode,
 429                                       glui32 rock)
 430  {
 431 -    strid_t (*funcPtr)(char *pathname, glui32 textmode, glui32 rock);
 432 +    static strid_t (*funcPtr)(char *pathname, glui32 textmode, glui32 rock);
 433 +
 434 +    if (! funcPtr) {
 435      char * errBuf = NULL;
 436
 437      funcPtr = loadSymbol(gGlkLib, "glkunix_stream_open_pathname", &errBuf);
 438 @@ -55,6 +57,7 @@
 439          fprintf(stderr, "%s\n", errBuf);
 440          exit(1);
 441      }
 442 +    }
 443
 444      return (*funcPtr)(pathname, textmode, rock);
 445  }
 446 @@ -62,7 +65,9 @@
 447  strid_t glkunix_stream_open_pathname_gen(char *pathname, glui32 writemode, glui32 textmode,
 448                                       glui32 rock)
 449  {
 450 -    strid_t (*funcPtr)(char *pathname, glui32 writemode, glui32 textmode, glui32 rock);
 451 +    static strid_t (*funcPtr)(char *pathname, glui32 writemode, glui32 textmode, glui32 rock);
 452 +
 453 +    if (! funcPtr) {
 454      char * errBuf = NULL;
 455
 456      funcPtr = loadSymbol(gGlkLib, "glkunix_stream_open_pathname_gen", &errBuf);
 457 @@ -70,13 +75,16 @@
 458          fprintf(stderr, "%s\n", errBuf);
 459          exit(1);
 460      }
 461 +    }
 462
 463      return (*funcPtr)(pathname, writemode, textmode, rock);
 464  }
 465
 466  void glkunix_set_base_file(char *filename)
 467  {
 468 -    void (*funcPtr)(char *filename);
 469 +    static void (*funcPtr)(char *filename);
 470 +
 471 +    if (! funcPtr) {
 472      char * errBuf = NULL;
 473
 474      funcPtr = loadSymbol(gGlkLib, "glkunix_set_base_file", &errBuf);
 475 @@ -84,6 +92,7 @@
 476          fprintf(stderr, "%s\n", errBuf);
 477          exit(1);
 478      }
 479 +    }
 480
 481      (*funcPtr)(filename);
 482  }