Attachment #148233 for bug #116062





    return (*funcPtr)();
}

giblorb_err_t giblorb_create_map(strid_t file, giblorb_map_t **newmap)
{
    giblorb_err_t (*funcPtr)(strid_t file, giblorb_map_t **newmap);
    char * errBuf = NULL;

    funcPtr = loadSymbol(gGlkLib, "giblorb_create_map", &errBuf);
    if (NULL != errBuf) {
        fprintf(stderr, "%s\n", errBuf);
        exit(1);
    }

    return (*funcPtr)(file, newmap);
}

giblorb_err_t giblorb_destroy_map(giblorb_map_t *map)
{
    giblorb_err_t (*funcPtr)(giblorb_map_t *map);
    char * errBuf = NULL;

    funcPtr = loadSymbol(gGlkLib, "giblorb_destroy_map", &errBuf);
    if (NULL != errBuf) {
        fprintf(stderr, "%s\n", errBuf);
        exit(1);
    }

    return (*funcPtr)(map);
}

giblorb_err_t giblorb_load_chunk_by_type(giblorb_map_t *map,
    glui32 method, giblorb_result_t *res, glui32 chunktype, glui32 count)
{
    giblorb_err_t (*funcPtr)(giblorb_map_t *map,
        glui32 method, giblorb_result_t *res, glui32 chunktype, glui32 count);
    char * errBuf = NULL;

    funcPtr = loadSymbol(gGlkLib, "giblorb_load_chunk_by_type", &errBuf);
    if (NULL != errBuf) {
        fprintf(stderr, "%s\n", errBuf);
        exit(1);
    }

    return (*funcPtr)(map, method, res, chunktype, count);
}

giblorb_err_t giblorb_load_chunk_by_number(giblorb_map_t *map,
    glui32 method, giblorb_result_t *res, glui32 chunknum)
{
    giblorb_err_t  (*funcPtr)(giblorb_map_t *map,
        glui32 method, giblorb_result_t *res, glui32 chunknum);
    char * errBuf = NULL;

    funcPtr = loadSymbol(gGlkLib, "giblorb_load_chunk_by_number", &errBuf);
    if (NULL != errBuf) {
        fprintf(stderr, "%s\n", errBuf);
        exit(1);
    }

    return (*funcPtr)(map, method, res, chunknum);
}

giblorb_err_t giblorb_unload_chunk(giblorb_map_t *map, glui32 chunknum)
{
    giblorb_err_t  (*funcPtr)(giblorb_map_t *map, glui32 chunknum);
    char * errBuf = NULL;

    funcPtr = loadSymbol(gGlkLib, "giblorb_unload_chunk", &errBuf);
    if (NULL != errBuf) {
        fprintf(stderr, "%s\n", errBuf);
        exit(1);
    }

    return (*funcPtr)(map, chunknum);
}

giblorb_err_t giblorb_load_resource(giblorb_map_t *map,
    glui32 method, giblorb_result_t *res, glui32 usage, glui32 resnum)
{
    giblorb_err_t  (*funcPtr)(giblorb_map_t *map,
        glui32 method, giblorb_result_t *res, glui32 usage, glui32 resnum);
    char * errBuf = NULL;

    funcPtr = loadSymbol(gGlkLib, "giblorb_load_resource", &errBuf);
    if (NULL != errBuf) {
        fprintf(stderr, "%s\n", errBuf);
        exit(1);
    }

    return (*funcPtr)(map, method, res, usage, resnum);
}

giblorb_err_t giblorb_count_resources(giblorb_map_t *map,
    glui32 usage, glui32 *num, glui32 *min, glui32 *max)
{
    giblorb_err_t  (*funcPtr)(giblorb_map_t *map,
        glui32 usage, glui32 *num, glui32 *min, glui32 *max);
    char * errBuf = NULL;

    funcPtr = loadSymbol(gGlkLib, "giblorb_count_resources", &errBuf);
    if (NULL != errBuf) {
        fprintf(stderr, "%s\n", errBuf);
        exit(1);
    }

    return (*funcPtr)(map, usage, num, min, max);
}

Lines 31-37 Link Here

(-)glkloader-0.3.2/Makefile~ (-1 / +1 lines)
31		31
32	OBJS = \	32	OBJS = \
33	glkloader.o glkfuncs.o blorbfuncs.o dispafuncs.o unixfuncs.o \	33	glkloader.o glkfuncs.o blorbfuncs.o dispafuncs.o unixfuncs.o \
34	linux_defines.o gi_blorb.o gi_dispa.o	34	linux_defines.o
35		35
36	HEADERS = \	36	HEADERS = \
37	defines.h linux_defines.h	37	defines.h linux_defines.h





    return (*funcPtr)(regi, unregi);
}

void gidispatch_call(glui32 funcnum, glui32 numargs, gluniversal_t *arglist)
{
    void (*funcPtr)(glui32 funcnum, glui32 numargs, gluniversal_t *arglist);
    char * errBuf = NULL;

    funcPtr = loadSymbol(gGlkLib, "gidispatch_call", &errBuf);
    if (NULL != errBuf) {
        fprintf(stderr, "%s\n", errBuf);
        exit(1);
    }

    return (*funcPtr)(funcnum, numargs, arglist);
}

char *gidispatch_prototype(glui32 funcnum)
{
    char * (*funcPtr)(glui32 funcnum);
    char * errBuf = NULL;

    funcPtr = loadSymbol(gGlkLib, "gidispatch_prototype", &errBuf);
    if (NULL != errBuf) {
        fprintf(stderr, "%s\n", errBuf);
        exit(1);
    }

    return (*funcPtr)(funcnum);
}

glui32 gidispatch_count_classes(void)
{
    glui32 (*funcPtr)(void);
    char * errBuf = NULL;

    funcPtr = loadSymbol(gGlkLib, "gidispatch_count_classes", &errBuf);
    if (NULL != errBuf) {
        fprintf(stderr, "%s\n", errBuf);
        exit(1);
    }

    return (*funcPtr)();
}

gidispatch_intconst_t *gidispatch_get_class(glui32 index)
{
    gidispatch_intconst_t * (*funcPtr)(glui32 index);
    char * errBuf = NULL;

    funcPtr = loadSymbol(gGlkLib, "gidispatch_get_class", &errBuf);
    if (NULL != errBuf) {
        fprintf(stderr, "%s\n", errBuf);
        exit(1);
    }

    return (*funcPtr)(index);
}

glui32 gidispatch_count_intconst(void)
{
    glui32 (*funcPtr)(void);
    char * errBuf = NULL;

    funcPtr = loadSymbol(gGlkLib, "gidispatch_count_intconst", &errBuf);
    if (NULL != errBuf) {
        fprintf(stderr, "%s\n", errBuf);
        exit(1);
    }

    return (*funcPtr)();
}

gidispatch_intconst_t *gidispatch_get_intconst(glui32 index)
{
    gidispatch_intconst_t * (*funcPtr)(glui32 index);
    char * errBuf = NULL;

    funcPtr = loadSymbol(gGlkLib, "gidispatch_get_intconst", &errBuf);
    if (NULL != errBuf) {
        fprintf(stderr, "%s\n", errBuf);
        exit(1);
    }

    return (*funcPtr)(index);
}

glui32 gidispatch_count_functions(void)
{
    glui32 (*funcPtr)(void);
    char * errBuf = NULL;

    funcPtr = loadSymbol(gGlkLib, "gidispatch_count_functions", &errBuf);
    if (NULL != errBuf) {
        fprintf(stderr, "%s\n", errBuf);
        exit(1);
    }

    return (*funcPtr)();
}

gidispatch_function_t *gidispatch_get_function(glui32 index)
{
    gidispatch_function_t * (*funcPtr)(glui32 index);
    char * errBuf = NULL;

    funcPtr = loadSymbol(gGlkLib, "gidispatch_get_function", &errBuf);
    if (NULL != errBuf) {
        fprintf(stderr, "%s\n", errBuf);
        exit(1);
    }

    return (*funcPtr)(index);
}

gidispatch_function_t *gidispatch_get_function_by_id(glui32 id)
{
    gidispatch_function_t * (*funcPtr)(glui32 id);
    char * errBuf = NULL;

    funcPtr = loadSymbol(gGlkLib, "gidispatch_get_function_by_id", &errBuf);
    if (NULL != errBuf) {
        fprintf(stderr, "%s\n", errBuf);
        exit(1);
    }

    return (*funcPtr)(id);
}

Return to bug 116062

Lines 71-73 Link Here

(-)glkloader-0.3.2/blorbfuncs.c~ (+106 lines)
71		71
72	return (*funcPtr)();	72	return (*funcPtr)();
73	}	73	}
		74
		75	giblorb_err_t giblorb_create_map(strid_t file, giblorb_map_t **newmap)
		76	{
		77	giblorb_err_t (funcPtr)(strid_t file, giblorb_map_t *newmap);
		78	char * errBuf = NULL;
		79
		80	funcPtr = loadSymbol(gGlkLib, "giblorb_create_map", &errBuf);
		81	if (NULL != errBuf) {
		82	fprintf(stderr, "%s\n", errBuf);
		83	exit(1);
		84	}
		85
		86	return (*funcPtr)(file, newmap);
		87	}
		88
		89	giblorb_err_t giblorb_destroy_map(giblorb_map_t *map)
		90	{
		91	giblorb_err_t (funcPtr)(giblorb_map_t map);
		92	char * errBuf = NULL;
		93
		94	funcPtr = loadSymbol(gGlkLib, "giblorb_destroy_map", &errBuf);
		95	if (NULL != errBuf) {
		96	fprintf(stderr, "%s\n", errBuf);
		97	exit(1);
		98	}
		99
		100	return (*funcPtr)(map);
		101	}
		102
		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	glui32 method, giblorb_result_t *res, glui32 chunktype, glui32 count);
		108	char * errBuf = NULL;
		109
		110	funcPtr = loadSymbol(gGlkLib, "giblorb_load_chunk_by_type", &errBuf);
		111	if (NULL != errBuf) {
		112	fprintf(stderr, "%s\n", errBuf);
		113	exit(1);
		114	}
		115
		116	return (*funcPtr)(map, method, res, chunktype, count);
		117	}
		118
		119	giblorb_err_t giblorb_load_chunk_by_number(giblorb_map_t *map,
		120	glui32 method, giblorb_result_t *res, glui32 chunknum)
		121	{
		122	giblorb_err_t (funcPtr)(giblorb_map_t map,
		123	glui32 method, giblorb_result_t *res, glui32 chunknum);
		124	char * errBuf = NULL;
		125
		126	funcPtr = loadSymbol(gGlkLib, "giblorb_load_chunk_by_number", &errBuf);
		127	if (NULL != errBuf) {
		128	fprintf(stderr, "%s\n", errBuf);
		129	exit(1);
		130	}
		131
		132	return (*funcPtr)(map, method, res, chunknum);
		133	}
		134
		135	giblorb_err_t giblorb_unload_chunk(giblorb_map_t *map, glui32 chunknum)
		136	{
		137	giblorb_err_t (funcPtr)(giblorb_map_t map, glui32 chunknum);
138	char * errBuf = NULL;
139
140	funcPtr = loadSymbol(gGlkLib, "giblorb_unload_chunk", &errBuf);
141	if (NULL != errBuf) {
142	fprintf(stderr, "%s\n", errBuf);
143	exit(1);
144	}
145
146	return (*funcPtr)(map, chunknum);
147	}
148
149	giblorb_err_t giblorb_load_resource(giblorb_map_t *map,
150	glui32 method, giblorb_result_t *res, glui32 usage, glui32 resnum)
151	{
152	giblorb_err_t (funcPtr)(giblorb_map_t map,
153	glui32 method, giblorb_result_t *res, glui32 usage, glui32 resnum);
154	char * errBuf = NULL;
155
156	funcPtr = loadSymbol(gGlkLib, "giblorb_load_resource", &errBuf);
157	if (NULL != errBuf) {
158	fprintf(stderr, "%s\n", errBuf);
159	exit(1);
160	}
161
162	return (*funcPtr)(map, method, res, usage, resnum);
163	}
164
165	giblorb_err_t giblorb_count_resources(giblorb_map_t *map,
166	glui32 usage, glui32 num, glui32 min, glui32 *max)
167	{
168	giblorb_err_t (funcPtr)(giblorb_map_t map,
169	glui32 usage, glui32 num, glui32 min, glui32 *max);
170	char * errBuf = NULL;
171
172	funcPtr = loadSymbol(gGlkLib, "giblorb_count_resources", &errBuf);
173	if (NULL != errBuf) {
174	fprintf(stderr, "%s\n", errBuf);
175	exit(1);
176	}
177
178	return (*funcPtr)(map, usage, num, min, max);
179	}

Lines 95-97 Link Here

(-)glkloader-0.3.2/dispafuncs.c~ (+126 lines)
95		95
96	return (*funcPtr)(regi, unregi);	96	return (*funcPtr)(regi, unregi);
97	}	97	}
		98
		99	void gidispatch_call(glui32 funcnum, glui32 numargs, gluniversal_t *arglist)
		100	{
		101	void (funcPtr)(glui32 funcnum, glui32 numargs, gluniversal_t arglist);
		102	char * errBuf = NULL;
		103
		104	funcPtr = loadSymbol(gGlkLib, "gidispatch_call", &errBuf);
		105	if (NULL != errBuf) {
		106	fprintf(stderr, "%s\n", errBuf);
		107	exit(1);
		108	}
		109
		110	return (*funcPtr)(funcnum, numargs, arglist);
		111	}
		112
		113	char *gidispatch_prototype(glui32 funcnum)
		114	{
		115	char * (*funcPtr)(glui32 funcnum);
		116	char * errBuf = NULL;
		117
		118	funcPtr = loadSymbol(gGlkLib, "gidispatch_prototype", &errBuf);
		119	if (NULL != errBuf) {
		120	fprintf(stderr, "%s\n", errBuf);
		121	exit(1);
		122	}
		123
		124	return (*funcPtr)(funcnum);
		125	}
		126
		127	glui32 gidispatch_count_classes(void)
		128	{
		129	glui32 (*funcPtr)(void);
		130	char * errBuf = NULL;
		131
		132	funcPtr = loadSymbol(gGlkLib, "gidispatch_count_classes", &errBuf);
		133	if (NULL != errBuf) {
		134	fprintf(stderr, "%s\n", errBuf);
		135	exit(1);
		136	}
		137
		138	return (*funcPtr)();
		139	}
		140
		141	gidispatch_intconst_t *gidispatch_get_class(glui32 index)
		142	{
		143	gidispatch_intconst_t * (*funcPtr)(glui32 index);
		144	char * errBuf = NULL;
		145
		146	funcPtr = loadSymbol(gGlkLib, "gidispatch_get_class", &errBuf);
		147	if (NULL != errBuf) {
		148	fprintf(stderr, "%s\n", errBuf);
		149	exit(1);
		150	}
		151
		152	return (*funcPtr)(index);
		153	}
		154
		155	glui32 gidispatch_count_intconst(void)
		156	{
		157	glui32 (*funcPtr)(void);
		158	char * errBuf = NULL;
		159
		160	funcPtr = loadSymbol(gGlkLib, "gidispatch_count_intconst", &errBuf);
		161	if (NULL != errBuf) {
162	fprintf(stderr, "%s\n", errBuf);
163	exit(1);
164	}
165
166	return (*funcPtr)();
167	}
168
169	gidispatch_intconst_t *gidispatch_get_intconst(glui32 index)
170	{
171	gidispatch_intconst_t * (*funcPtr)(glui32 index);
172	char * errBuf = NULL;
173
174	funcPtr = loadSymbol(gGlkLib, "gidispatch_get_intconst", &errBuf);
175	if (NULL != errBuf) {
176	fprintf(stderr, "%s\n", errBuf);
177	exit(1);
178	}
179
180	return (*funcPtr)(index);
181	}
182
183	glui32 gidispatch_count_functions(void)
184	{
185	glui32 (*funcPtr)(void);
186	char * errBuf = NULL;
187
188	funcPtr = loadSymbol(gGlkLib, "gidispatch_count_functions", &errBuf);
189	if (NULL != errBuf) {
190	fprintf(stderr, "%s\n", errBuf);
191	exit(1);
192	}
193
194	return (*funcPtr)();
195	}
196
197	gidispatch_function_t *gidispatch_get_function(glui32 index)
198	{
199	gidispatch_function_t * (*funcPtr)(glui32 index);
200	char * errBuf = NULL;
201
202	funcPtr = loadSymbol(gGlkLib, "gidispatch_get_function", &errBuf);
203	if (NULL != errBuf) {
204	fprintf(stderr, "%s\n", errBuf);
205	exit(1);
206	}
207
208	return (*funcPtr)(index);
209	}
210
211	gidispatch_function_t *gidispatch_get_function_by_id(glui32 id)
212	{
213	gidispatch_function_t * (*funcPtr)(glui32 id);
214	char * errBuf = NULL;
215
216	funcPtr = loadSymbol(gGlkLib, "gidispatch_get_function_by_id", &errBuf);
217	if (NULL != errBuf) {
218	fprintf(stderr, "%s\n", errBuf);
219	exit(1);
220	}
221
222	return (*funcPtr)(id);
223	}