dev-games/glkloader/files/glkloader-0.3.2-dynamic-blorb-dispa.patch

   1 Source: dleverton
   2 Upstream: submitted
   3 Reason: use the real Glk library's copies of the blorb and dispatch
   4         layer rather than our own; in the case of the dispatch layer
   5         at least, this in theory might allow for better errors when
   6         the game calls a function not present in this version of Glk
   7
   8 --- glkloader-0.3.2/blorbfuncs.c~       2001-03-14 03:07:58.000000000 +0000
   9 +++ glkloader-0.3.2/blorbfuncs.c        2007-12-09 11:28:31.000000000 +0000
  10 @@ -71,3 +71,109 @@
  11
  12      return (*funcPtr)();
  13  }
  14 +
  15 +giblorb_err_t giblorb_create_map(strid_t file, giblorb_map_t **newmap)
  16 +{
  17 +    giblorb_err_t (*funcPtr)(strid_t file, giblorb_map_t **newmap);
  18 +    char * errBuf = NULL;
  19 +
  20 +    funcPtr = loadSymbol(gGlkLib, "giblorb_create_map", &errBuf);
  21 +    if (NULL != errBuf) {
  22 +        fprintf(stderr, "%s\n", errBuf);
  23 +        exit(1);
  24 +    }
  25 +
  26 +    return (*funcPtr)(file, newmap);
  27 +}
  28 +
  29 +giblorb_err_t giblorb_destroy_map(giblorb_map_t *map)
  30 +{
  31 +    giblorb_err_t (*funcPtr)(giblorb_map_t *map);
  32 +    char * errBuf = NULL;
  33 +
  34 +    funcPtr = loadSymbol(gGlkLib, "giblorb_destroy_map", &errBuf);
  35 +    if (NULL != errBuf) {
  36 +        fprintf(stderr, "%s\n", errBuf);
  37 +        exit(1);
  38 +    }
  39 +
  40 +    return (*funcPtr)(map);
  41 +}
  42 +
  43 +giblorb_err_t giblorb_load_chunk_by_type(giblorb_map_t *map,
  44 +    glui32 method, giblorb_result_t *res, glui32 chunktype, glui32 count)
  45 +{
  46 +    giblorb_err_t (*funcPtr)(giblorb_map_t *map,
  47 +        glui32 method, giblorb_result_t *res, glui32 chunktype, glui32 count);
  48 +    char * errBuf = NULL;
  49 +
  50 +    funcPtr = loadSymbol(gGlkLib, "giblorb_load_chunk_by_type", &errBuf);
  51 +    if (NULL != errBuf) {
  52 +        fprintf(stderr, "%s\n", errBuf);
  53 +        exit(1);
  54 +    }
  55 +
  56 +    return (*funcPtr)(map, method, res, chunktype, count);
  57 +}
  58 +
  59 +giblorb_err_t giblorb_load_chunk_by_number(giblorb_map_t *map,
  60 +    glui32 method, giblorb_result_t *res, glui32 chunknum)
  61 +{
  62 +    giblorb_err_t  (*funcPtr)(giblorb_map_t *map,
  63 +        glui32 method, giblorb_result_t *res, glui32 chunknum);
  64 +    char * errBuf = NULL;
  65 +
  66 +    funcPtr = loadSymbol(gGlkLib, "giblorb_load_chunk_by_number", &errBuf);
  67 +    if (NULL != errBuf) {
  68 +        fprintf(stderr, "%s\n", errBuf);
  69 +        exit(1);
  70 +    }
  71 +
  72 +    return (*funcPtr)(map, method, res, chunknum);
  73 +}
  74 +
  75 +giblorb_err_t giblorb_unload_chunk(giblorb_map_t *map, glui32 chunknum)
  76 +{
  77 +    giblorb_err_t  (*funcPtr)(giblorb_map_t *map, glui32 chunknum);
  78 +    char * errBuf = NULL;
  79 +
  80 +    funcPtr = loadSymbol(gGlkLib, "giblorb_unload_chunk", &errBuf);
  81 +    if (NULL != errBuf) {
  82 +        fprintf(stderr, "%s\n", errBuf);
  83 +        exit(1);
  84 +    }
  85 +
  86 +    return (*funcPtr)(map, chunknum);
  87 +}
  88 +
  89 +giblorb_err_t giblorb_load_resource(giblorb_map_t *map,
  90 +    glui32 method, giblorb_result_t *res, glui32 usage, glui32 resnum)
  91 +{
  92 +    giblorb_err_t  (*funcPtr)(giblorb_map_t *map,
  93 +        glui32 method, giblorb_result_t *res, glui32 usage, glui32 resnum);
  94 +    char * errBuf = NULL;
  95 +
  96 +    funcPtr = loadSymbol(gGlkLib, "giblorb_load_resource", &errBuf);
  97 +    if (NULL != errBuf) {
  98 +        fprintf(stderr, "%s\n", errBuf);
  99 +        exit(1);
 100 +    }
 101 +
 102 +    return (*funcPtr)(map, method, res, usage, resnum);
 103 +}
 104 +
 105 +giblorb_err_t giblorb_count_resources(giblorb_map_t *map,
 106 +    glui32 usage, glui32 *num, glui32 *min, glui32 *max)
 107 +{
 108 +    giblorb_err_t  (*funcPtr)(giblorb_map_t *map,
 109 +        glui32 usage, glui32 *num, glui32 *min, glui32 *max);
 110 +    char * errBuf = NULL;
 111 +
 112 +    funcPtr = loadSymbol(gGlkLib, "giblorb_count_resources", &errBuf);
 113 +    if (NULL != errBuf) {
 114 +        fprintf(stderr, "%s\n", errBuf);
 115 +        exit(1);
 116 +    }
 117 +
 118 +    return (*funcPtr)(map, usage, num, min, max);
 119 +}
 120 --- glkloader-0.3.2/Makefile~   2007-12-09 11:18:08.000000000 +0000
 121 +++ glkloader-0.3.2/Makefile    2007-12-09 11:28:40.000000000 +0000
 122 @@ -31,7 +31,7 @@
 123
 124  OBJS =  \
 125         glkloader.o glkfuncs.o blorbfuncs.o dispafuncs.o unixfuncs.o \
 126 -    linux_defines.o gi_blorb.o gi_dispa.o
 127 +    linux_defines.o
 128
 129  HEADERS = \
 130         defines.h linux_defines.h
 131 --- glkloader-0.3.2/dispafuncs.c~       2001-03-14 03:07:59.000000000 +0000
 132 +++ glkloader-0.3.2/dispafuncs.c        2007-12-09 11:30:51.000000000 +0000
 133 @@ -95,3 +95,129 @@
 134
 135      return (*funcPtr)(regi, unregi);
 136  }
 137 +
 138 +void gidispatch_call(glui32 funcnum, glui32 numargs, gluniversal_t *arglist)
 139 +{
 140 +    void (*funcPtr)(glui32 funcnum, glui32 numargs, gluniversal_t *arglist);
 141 +    char * errBuf = NULL;
 142 +
 143 +    funcPtr = loadSymbol(gGlkLib, "gidispatch_call", &errBuf);
 144 +    if (NULL != errBuf) {
 145 +        fprintf(stderr, "%s\n", errBuf);
 146 +        exit(1);
 147 +    }
 148 +
 149 +    return (*funcPtr)(funcnum, numargs, arglist);
 150 +}
 151 +
 152 +char *gidispatch_prototype(glui32 funcnum)
 153 +{
 154 +    char * (*funcPtr)(glui32 funcnum);
 155 +    char * errBuf = NULL;
 156 +
 157 +    funcPtr = loadSymbol(gGlkLib, "gidispatch_prototype", &errBuf);
 158 +    if (NULL != errBuf) {
 159 +        fprintf(stderr, "%s\n", errBuf);
 160 +        exit(1);
 161 +    }
 162 +
 163 +    return (*funcPtr)(funcnum);
 164 +}
 165 +
 166 +glui32 gidispatch_count_classes(void)
 167 +{
 168 +    glui32 (*funcPtr)(void);
 169 +    char * errBuf = NULL;
 170 +
 171 +    funcPtr = loadSymbol(gGlkLib, "gidispatch_count_classes", &errBuf);
 172 +    if (NULL != errBuf) {
 173 +        fprintf(stderr, "%s\n", errBuf);
 174 +        exit(1);
 175 +    }
 176 +
 177 +    return (*funcPtr)();
 178 +}
 179 +
 180 +gidispatch_intconst_t *gidispatch_get_class(glui32 index)
 181 +{
 182 +    gidispatch_intconst_t * (*funcPtr)(glui32 index);
 183 +    char * errBuf = NULL;
 184 +
 185 +    funcPtr = loadSymbol(gGlkLib, "gidispatch_get_class", &errBuf);
 186 +    if (NULL != errBuf) {
 187 +        fprintf(stderr, "%s\n", errBuf);
 188 +        exit(1);
 189 +    }
 190 +
 191 +    return (*funcPtr)(index);
 192 +}
 193 +
 194 +glui32 gidispatch_count_intconst(void)
 195 +{
 196 +    glui32 (*funcPtr)(void);
 197 +    char * errBuf = NULL;
 198 +
 199 +    funcPtr = loadSymbol(gGlkLib, "gidispatch_count_intconst", &errBuf);
 200 +    if (NULL != errBuf) {
 201 +        fprintf(stderr, "%s\n", errBuf);
 202 +        exit(1);
 203 +    }
 204 +
 205 +    return (*funcPtr)();
 206 +}
 207 +
 208 +gidispatch_intconst_t *gidispatch_get_intconst(glui32 index)
 209 +{
 210 +    gidispatch_intconst_t * (*funcPtr)(glui32 index);
 211 +    char * errBuf = NULL;
 212 +
 213 +    funcPtr = loadSymbol(gGlkLib, "gidispatch_get_intconst", &errBuf);
 214 +    if (NULL != errBuf) {
 215 +        fprintf(stderr, "%s\n", errBuf);
 216 +        exit(1);
 217 +    }
 218 +
 219 +    return (*funcPtr)(index);
 220 +}
 221 +
 222 +glui32 gidispatch_count_functions(void)
 223 +{
 224 +    glui32 (*funcPtr)(void);
 225 +    char * errBuf = NULL;
 226 +
 227 +    funcPtr = loadSymbol(gGlkLib, "gidispatch_count_functions", &errBuf);
 228 +    if (NULL != errBuf) {
 229 +        fprintf(stderr, "%s\n", errBuf);
 230 +        exit(1);
 231 +    }
 232 +
 233 +    return (*funcPtr)();
 234 +}
 235 +
 236 +gidispatch_function_t *gidispatch_get_function(glui32 index)
 237 +{
 238 +    gidispatch_function_t * (*funcPtr)(glui32 index);
 239 +    char * errBuf = NULL;
 240 +
 241 +    funcPtr = loadSymbol(gGlkLib, "gidispatch_get_function", &errBuf);
 242 +    if (NULL != errBuf) {
 243 +        fprintf(stderr, "%s\n", errBuf);
 244 +        exit(1);
 245 +    }
 246 +
 247 +    return (*funcPtr)(index);
 248 +}
 249 +
 250 +gidispatch_function_t *gidispatch_get_function_by_id(glui32 id)
 251 +{
 252 +    gidispatch_function_t * (*funcPtr)(glui32 id);
 253 +    char * errBuf = NULL;
 254 +
 255 +    funcPtr = loadSymbol(gGlkLib, "gidispatch_get_function_by_id", &errBuf);
 256 +    if (NULL != errBuf) {
 257 +        fprintf(stderr, "%s\n", errBuf);
 258 +        exit(1);
 259 +    }
 260 +
 261 +    return (*funcPtr)(id);
 262 +}