Attachment #148235 for bug #116062

Lines 307-313 Link Here

(-)glkloader-0.3.2/generate_glkfuncs.pl~ (-1 / +4 lines)
307		307
308	print OUT_FILE "$ret_type $name(", createArgList (@arg_list), ")\n";	308	print OUT_FILE "$ret_type $name(", createArgList (@arg_list), ")\n";
309	print OUT_FILE "{\n";	309	print OUT_FILE "{\n";
310	print OUT_FILE " $ret_type (*funcPtr)(", createArgList (@arg_list), ");\n";	310	print OUT_FILE " static $ret_type (*funcPtr)(", createArgList (@arg_list), ");\n";
		311	print OUT_FILE "\n";
		312	print OUT_FILE " if (! funcPtr) {\n";
311	print OUT_FILE " char * errBuf = NULL;\n";	313	print OUT_FILE " char * errBuf = NULL;\n";
312	print OUT_FILE "\n";	314	print OUT_FILE "\n";
313	print OUT_FILE " funcPtr = loadSymbol(gGlkLib, \"$name\", &errBuf);\n";	315	print OUT_FILE " funcPtr = loadSymbol(gGlkLib, \"$name\", &errBuf);\n";
Lines 315-320 Link Here
315	print OUT_FILE " fprintf(stderr, \"%s\\n\", errBuf);\n";	317	print OUT_FILE " fprintf(stderr, \"%s\\n\", errBuf);\n";
316	print OUT_FILE " exit(1);\n";	318	print OUT_FILE " exit(1);\n";
317	print OUT_FILE " }\n";	319	print OUT_FILE " }\n";
		320	print OUT_FILE " }\n";
318	print OUT_FILE "\n";	321	print OUT_FILE "\n";
319	if ($ret_type eq "void")	322	if ($ret_type eq "void")
320	{	323	{

Lines 46-52 Link Here

(-)glkloader-0.3.2/blorbfuncs.c~ (-9 / +36 lines)
46		46
47	giblorb_err_t giblorb_set_resource_map(strid_t file)	47	giblorb_err_t giblorb_set_resource_map(strid_t file)
48	{	48	{
49	giblorb_err_t (*funcPtr)(strid_t file);	49	static giblorb_err_t (*funcPtr)(strid_t file);
		50
		51	if (! funcPtr) {
50	char * errBuf = NULL;	52	char * errBuf = NULL;
51		53
52	funcPtr = loadSymbol(gGlkLib, "giblorb_set_resource_map", &errBuf);	54	funcPtr = loadSymbol(gGlkLib, "giblorb_set_resource_map", &errBuf);
Lines 54-66 Link Here
54	fprintf(stderr, "%s\n", errBuf);	56	fprintf(stderr, "%s\n", errBuf);
55	exit(1);	57	exit(1);
56	}	58	}
		59	}
57		60
58	return (*funcPtr)(file);	61	return (*funcPtr)(file);
59	}	62	}
60		63
61	giblorb_map_t *giblorb_get_resource_map(void)	64	giblorb_map_t *giblorb_get_resource_map(void)
62	{	65	{
63	giblorb_map_t * (*funcPtr)(void);	66	static giblorb_map_t * (*funcPtr)(void);
		67
		68	if (! funcPtr) {
64	char * errBuf = NULL;	69	char * errBuf = NULL;
65		70
66	funcPtr = loadSymbol(gGlkLib, "giblorb_get_resource_map", &errBuf);	71	funcPtr = loadSymbol(gGlkLib, "giblorb_get_resource_map", &errBuf);
Lines 68-80 Link Here
68	fprintf(stderr, "%s\n", errBuf);	73	fprintf(stderr, "%s\n", errBuf);
69	exit(1);	74	exit(1);
70	}	75	}
		76	}
71		77
72	return (*funcPtr)();	78	return (*funcPtr)();
73	}	79	}
74		80
75	giblorb_err_t giblorb_create_map(strid_t file, giblorb_map_t **newmap)	81	giblorb_err_t giblorb_create_map(strid_t file, giblorb_map_t **newmap)
76	{	82	{
77	giblorb_err_t (funcPtr)(strid_t file, giblorb_map_t *newmap);	83	static giblorb_err_t (funcPtr)(strid_t file, giblorb_map_t *newmap);
		84
		85	if (! funcPtr) {
78	char * errBuf = NULL;	86	char * errBuf = NULL;
79		87
80	funcPtr = loadSymbol(gGlkLib, "giblorb_create_map", &errBuf);	88	funcPtr = loadSymbol(gGlkLib, "giblorb_create_map", &errBuf);
Lines 82-94 Link Here
82	fprintf(stderr, "%s\n", errBuf);	90	fprintf(stderr, "%s\n", errBuf);
83	exit(1);	91	exit(1);
84	}	92	}
		93	}
85		94
86	return (*funcPtr)(file, newmap);	95	return (*funcPtr)(file, newmap);
87	}	96	}
88		97
89	giblorb_err_t giblorb_destroy_map(giblorb_map_t *map)	98	giblorb_err_t giblorb_destroy_map(giblorb_map_t *map)
90	{	99	{
91	giblorb_err_t (funcPtr)(giblorb_map_t map);	100	static giblorb_err_t (funcPtr)(giblorb_map_t map);
		101
		102	if (! funcPtr) {
92	char * errBuf = NULL;	103	char * errBuf = NULL;
93		104
94	funcPtr = loadSymbol(gGlkLib, "giblorb_destroy_map", &errBuf);	105	funcPtr = loadSymbol(gGlkLib, "giblorb_destroy_map", &errBuf);
Lines 96-101 Link Here
96	fprintf(stderr, "%s\n", errBuf);	107	fprintf(stderr, "%s\n", errBuf);
97	exit(1);	108	exit(1);
98	}	109	}
		110	}
99		111
100	return (*funcPtr)(map);	112	return (*funcPtr)(map);
101	}	113	}
Lines 103-110 Link Here
103	giblorb_err_t giblorb_load_chunk_by_type(giblorb_map_t *map,	115	giblorb_err_t giblorb_load_chunk_by_type(giblorb_map_t *map,
104	glui32 method, giblorb_result_t *res, glui32 chunktype, glui32 count)	116	glui32 method, giblorb_result_t *res, glui32 chunktype, glui32 count)
105	{	117	{
106	giblorb_err_t (funcPtr)(giblorb_map_t map,	118	static giblorb_err_t (funcPtr)(giblorb_map_t map,
107	glui32 method, giblorb_result_t *res, glui32 chunktype, glui32 count);	119	glui32 method, giblorb_result_t *res, glui32 chunktype, glui32 count);
		120
		121	if (! funcPtr) {
108	char * errBuf = NULL;	122	char * errBuf = NULL;
109		123
110	funcPtr = loadSymbol(gGlkLib, "giblorb_load_chunk_by_type", &errBuf);	124	funcPtr = loadSymbol(gGlkLib, "giblorb_load_chunk_by_type", &errBuf);
Lines 112-117 Link Here
112	fprintf(stderr, "%s\n", errBuf);	126	fprintf(stderr, "%s\n", errBuf);
113	exit(1);	127	exit(1);
114	}	128	}
		129	}
115		130
116	return (*funcPtr)(map, method, res, chunktype, count);	131	return (*funcPtr)(map, method, res, chunktype, count);
117	}	132	}
Lines 119-126 Link Here
119	giblorb_err_t giblorb_load_chunk_by_number(giblorb_map_t *map,	134	giblorb_err_t giblorb_load_chunk_by_number(giblorb_map_t *map,
120	glui32 method, giblorb_result_t *res, glui32 chunknum)	135	glui32 method, giblorb_result_t *res, glui32 chunknum)
121	{	136	{
122	giblorb_err_t (funcPtr)(giblorb_map_t map,	137	static giblorb_err_t (funcPtr)(giblorb_map_t map,
123	glui32 method, giblorb_result_t *res, glui32 chunknum);	138	glui32 method, giblorb_result_t *res, glui32 chunknum);
		139
		140	if (! funcPtr) {
124	char * errBuf = NULL;	141	char * errBuf = NULL;
125		142
126	funcPtr = loadSymbol(gGlkLib, "giblorb_load_chunk_by_number", &errBuf);	143	funcPtr = loadSymbol(gGlkLib, "giblorb_load_chunk_by_number", &errBuf);
Lines 128-140 Link Here
128	fprintf(stderr, "%s\n", errBuf);	145	fprintf(stderr, "%s\n", errBuf);
129	exit(1);	146	exit(1);
130	}	147	}
		148	}
131		149
132	return (*funcPtr)(map, method, res, chunknum);	150	return (*funcPtr)(map, method, res, chunknum);
133	}	151	}
134		152
135	giblorb_err_t giblorb_unload_chunk(giblorb_map_t *map, glui32 chunknum)	153	giblorb_err_t giblorb_unload_chunk(giblorb_map_t *map, glui32 chunknum)
136	{	154	{
137	giblorb_err_t (funcPtr)(giblorb_map_t map, glui32 chunknum);	155	static giblorb_err_t (funcPtr)(giblorb_map_t map, glui32 chunknum);
		156
		157	if (! funcPtr) {
138	char * errBuf = NULL;	158	char * errBuf = NULL;
139		159
140	funcPtr = loadSymbol(gGlkLib, "giblorb_unload_chunk", &errBuf);	160	funcPtr = loadSymbol(gGlkLib, "giblorb_unload_chunk", &errBuf);
Lines 142-147 Link Here
142	fprintf(stderr, "%s\n", errBuf);	162	fprintf(stderr, "%s\n", errBuf);
143	exit(1);	163	exit(1);
144	}	164	}
		165	}
145		166
146	return (*funcPtr)(map, chunknum);	167	return (*funcPtr)(map, chunknum);
147	}	168	}
Lines 149-156 Link Here
149	giblorb_err_t giblorb_load_resource(giblorb_map_t *map,	170	giblorb_err_t giblorb_load_resource(giblorb_map_t *map,
150	glui32 method, giblorb_result_t *res, glui32 usage, glui32 resnum)	171	glui32 method, giblorb_result_t *res, glui32 usage, glui32 resnum)
151	{	172	{
152	giblorb_err_t (funcPtr)(giblorb_map_t map,	173	static giblorb_err_t (funcPtr)(giblorb_map_t map,
153	glui32 method, giblorb_result_t *res, glui32 usage, glui32 resnum);	174	glui32 method, giblorb_result_t *res, glui32 usage, glui32 resnum);
		175
		176	if (! funcPtr) {
154	char * errBuf = NULL;	177	char * errBuf = NULL;
155		178
156	funcPtr = loadSymbol(gGlkLib, "giblorb_load_resource", &errBuf);	179	funcPtr = loadSymbol(gGlkLib, "giblorb_load_resource", &errBuf);
Lines 158-163 Link Here
158	fprintf(stderr, "%s\n", errBuf);	181	fprintf(stderr, "%s\n", errBuf);
159	exit(1);	182	exit(1);
160	}	183	}
		184	}
161		185
162	return (*funcPtr)(map, method, res, usage, resnum);	186	return (*funcPtr)(map, method, res, usage, resnum);
163	}	187	}
Lines 165-172 Link Here
165	giblorb_err_t giblorb_count_resources(giblorb_map_t *map,	189	giblorb_err_t giblorb_count_resources(giblorb_map_t *map,
166	glui32 usage, glui32 num, glui32 min, glui32 *max)	190	glui32 usage, glui32 num, glui32 min, glui32 *max)
167	{	191	{
168	giblorb_err_t (funcPtr)(giblorb_map_t map,	192	static giblorb_err_t (funcPtr)(giblorb_map_t map,
169	glui32 usage, glui32 num, glui32 min, glui32 *max);	193	glui32 usage, glui32 num, glui32 min, glui32 *max);
		194
		195	if (! funcPtr) {
170	char * errBuf = NULL;	196	char * errBuf = NULL;
171		197
172	funcPtr = loadSymbol(gGlkLib, "giblorb_count_resources", &errBuf);	198	funcPtr = loadSymbol(gGlkLib, "giblorb_count_resources", &errBuf);
Lines 174-179 Link Here
174	fprintf(stderr, "%s\n", errBuf);	200	fprintf(stderr, "%s\n", errBuf);
175	exit(1);	201	exit(1);
176	}	202	}
		203	}
177		204
178	return (*funcPtr)(map, usage, num, min, max);	205	return (*funcPtr)(map, usage, num, min, max);
179	}	206	}

Lines 48-56 Link Here

(-)glkloader-0.3.2/dispafuncs.c~ (-12 / +48 lines)
48	gidispatch_rock_t (regi)(void obj, glui32 objclass),	48	gidispatch_rock_t (regi)(void obj, glui32 objclass),
49	void (unregi)(void obj, glui32 objclass, gidispatch_rock_t objrock))	49	void (unregi)(void obj, glui32 objclass, gidispatch_rock_t objrock))
50	{	50	{
51	void (*funcPtr)(	51	static void (*funcPtr)(
52	gidispatch_rock_t (regi)(void obj, glui32 objclass),	52	gidispatch_rock_t (regi)(void obj, glui32 objclass),
53	void (unregi)(void obj, glui32 objclass, gidispatch_rock_t objrock));	53	void (unregi)(void obj, glui32 objclass, gidispatch_rock_t objrock));
		54
		55	if (! funcPtr) {
54	char * errBuf = NULL;	56	char * errBuf = NULL;
55		57
56	funcPtr = loadSymbol(gGlkLib, "gidispatch_set_object_registry", &errBuf);	58	funcPtr = loadSymbol(gGlkLib, "gidispatch_set_object_registry", &errBuf);
Lines 58-70 Link Here
58	fprintf(stderr, "%s\n", errBuf);	60	fprintf(stderr, "%s\n", errBuf);
59	exit(1);	61	exit(1);
60	}	62	}
		63	}
61		64
62	(*funcPtr)(regi, unregi);	65	(*funcPtr)(regi, unregi);
63	}	66	}
64		67
65	gidispatch_rock_t gidispatch_get_objrock(void *obj, glui32 objclass)	68	gidispatch_rock_t gidispatch_get_objrock(void *obj, glui32 objclass)
66	{	69	{
67	gidispatch_rock_t (funcPtr)(void obj, glui32 objclass);	70	static gidispatch_rock_t (funcPtr)(void obj, glui32 objclass);
		71
		72	if (! funcPtr) {
68	char * errBuf = NULL;	73	char * errBuf = NULL;
69		74
70	funcPtr = loadSymbol(gGlkLib, "gidispatch_get_objrock", &errBuf);	75	funcPtr = loadSymbol(gGlkLib, "gidispatch_get_objrock", &errBuf);
Lines 72-77 Link Here
72	fprintf(stderr, "%s\n", errBuf);	77	fprintf(stderr, "%s\n", errBuf);
73	exit(1);	78	exit(1);
74	}	79	}
		80	}
75		81
76	return (*funcPtr)(obj, objclass);	82	return (*funcPtr)(obj, objclass);
77	}	83	}
Lines 81-90 Link Here
81	void (unregi)(void array, glui32 len, char *typecode,	87	void (unregi)(void array, glui32 len, char *typecode,
82	gidispatch_rock_t objrock))	88	gidispatch_rock_t objrock))
83	{	89	{
84	void (*funcPtr)(	90	static void (*funcPtr)(
85	gidispatch_rock_t (regi)(void array, glui32 len, char *typecode),	91	gidispatch_rock_t (regi)(void array, glui32 len, char *typecode),
86	void (unregi)(void array, glui32 len, char *typecode,	92	void (unregi)(void array, glui32 len, char *typecode,
87	gidispatch_rock_t objrock));	93	gidispatch_rock_t objrock));
		94
		95	if (! funcPtr) {
88	char * errBuf = NULL;	96	char * errBuf = NULL;
89		97
90	funcPtr = loadSymbol(gGlkLib, "gidispatch_set_retained_registry", &errBuf);	98	funcPtr = loadSymbol(gGlkLib, "gidispatch_set_retained_registry", &errBuf);
Lines 92-104 Link Here
92	fprintf(stderr, "%s\n", errBuf);	100	fprintf(stderr, "%s\n", errBuf);
93	exit(1);	101	exit(1);
94	}	102	}
		103	}
95		104
96	return (*funcPtr)(regi, unregi);	105	return (*funcPtr)(regi, unregi);
97	}	106	}
98		107
99	void gidispatch_call(glui32 funcnum, glui32 numargs, gluniversal_t *arglist)	108	void gidispatch_call(glui32 funcnum, glui32 numargs, gluniversal_t *arglist)
100	{	109	{
101	void (funcPtr)(glui32 funcnum, glui32 numargs, gluniversal_t arglist);	110	static void (funcPtr)(glui32 funcnum, glui32 numargs, gluniversal_t arglist);
		111
		112	if (! funcPtr) {
102	char * errBuf = NULL;	113	char * errBuf = NULL;
103		114
104	funcPtr = loadSymbol(gGlkLib, "gidispatch_call", &errBuf);	115	funcPtr = loadSymbol(gGlkLib, "gidispatch_call", &errBuf);
Lines 106-118 Link Here
106	fprintf(stderr, "%s\n", errBuf);	117	fprintf(stderr, "%s\n", errBuf);
107	exit(1);	118	exit(1);
108	}	119	}
		120	}
109		121
110	return (*funcPtr)(funcnum, numargs, arglist);	122	return (*funcPtr)(funcnum, numargs, arglist);
111	}	123	}
112		124
113	char *gidispatch_prototype(glui32 funcnum)	125	char *gidispatch_prototype(glui32 funcnum)
114	{	126	{
115	char * (*funcPtr)(glui32 funcnum);	127	static char * (*funcPtr)(glui32 funcnum);
		128
		129	if (! funcPtr) {
116	char * errBuf = NULL;	130	char * errBuf = NULL;
117		131
118	funcPtr = loadSymbol(gGlkLib, "gidispatch_prototype", &errBuf);	132	funcPtr = loadSymbol(gGlkLib, "gidispatch_prototype", &errBuf);
Lines 120-132 Link Here
120	fprintf(stderr, "%s\n", errBuf);	134	fprintf(stderr, "%s\n", errBuf);
121	exit(1);	135	exit(1);
122	}	136	}
		137	}
123		138
124	return (*funcPtr)(funcnum);	139	return (*funcPtr)(funcnum);
125	}	140	}
126		141
127	glui32 gidispatch_count_classes(void)	142	glui32 gidispatch_count_classes(void)
128	{	143	{
129	glui32 (*funcPtr)(void);	144	static glui32 (*funcPtr)(void);
		145
		146	if (! funcPtr) {
130	char * errBuf = NULL;	147	char * errBuf = NULL;
131		148
132	funcPtr = loadSymbol(gGlkLib, "gidispatch_count_classes", &errBuf);	149	funcPtr = loadSymbol(gGlkLib, "gidispatch_count_classes", &errBuf);
Lines 134-146 Link Here
134	fprintf(stderr, "%s\n", errBuf);	151	fprintf(stderr, "%s\n", errBuf);
135	exit(1);	152	exit(1);
136	}	153	}
		154	}
137		155
138	return (*funcPtr)();	156	return (*funcPtr)();
139	}	157	}
140		158
141	gidispatch_intconst_t *gidispatch_get_class(glui32 index)	159	gidispatch_intconst_t *gidispatch_get_class(glui32 index)
142	{	160	{
143	gidispatch_intconst_t * (*funcPtr)(glui32 index);	161	static gidispatch_intconst_t * (*funcPtr)(glui32 index);
		162
		163	if (! funcPtr) {
144	char * errBuf = NULL;	164	char * errBuf = NULL;
145		165
146	funcPtr = loadSymbol(gGlkLib, "gidispatch_get_class", &errBuf);	166	funcPtr = loadSymbol(gGlkLib, "gidispatch_get_class", &errBuf);
Lines 148-160 Link Here
148	fprintf(stderr, "%s\n", errBuf);	168	fprintf(stderr, "%s\n", errBuf);
149	exit(1);	169	exit(1);
150	}	170	}
		171	}
151		172
152	return (*funcPtr)(index);	173	return (*funcPtr)(index);
153	}	174	}
154		175
155	glui32 gidispatch_count_intconst(void)	176	glui32 gidispatch_count_intconst(void)
156	{	177	{
157	glui32 (*funcPtr)(void);	178	static glui32 (*funcPtr)(void);
		179
		180	if (! funcPtr) {
158	char * errBuf = NULL;	181	char * errBuf = NULL;
159		182
160	funcPtr = loadSymbol(gGlkLib, "gidispatch_count_intconst", &errBuf);	183	funcPtr = loadSymbol(gGlkLib, "gidispatch_count_intconst", &errBuf);
Lines 162-174 Link Here
162	fprintf(stderr, "%s\n", errBuf);	185	fprintf(stderr, "%s\n", errBuf);
163	exit(1);	186	exit(1);
164	}	187	}
		188	}
165		189
166	return (*funcPtr)();	190	return (*funcPtr)();
167	}	191	}
168		192
169	gidispatch_intconst_t *gidispatch_get_intconst(glui32 index)	193	gidispatch_intconst_t *gidispatch_get_intconst(glui32 index)
170	{	194	{
171	gidispatch_intconst_t * (*funcPtr)(glui32 index);	195	static gidispatch_intconst_t * (*funcPtr)(glui32 index);
		196
		197	if (! funcPtr) {
172	char * errBuf = NULL;	198	char * errBuf = NULL;
173		199
174	funcPtr = loadSymbol(gGlkLib, "gidispatch_get_intconst", &errBuf);	200	funcPtr = loadSymbol(gGlkLib, "gidispatch_get_intconst", &errBuf);
Lines 176-188 Link Here
176	fprintf(stderr, "%s\n", errBuf);	202	fprintf(stderr, "%s\n", errBuf);
177	exit(1);	203	exit(1);
178	}	204	}
		205	}
179		206
180	return (*funcPtr)(index);	207	return (*funcPtr)(index);
181	}	208	}
182		209
183	glui32 gidispatch_count_functions(void)	210	glui32 gidispatch_count_functions(void)
184	{	211	{
185	glui32 (*funcPtr)(void);	212	static glui32 (*funcPtr)(void);
		213
		214	if (! funcPtr) {
186	char * errBuf = NULL;	215	char * errBuf = NULL;
187		216
188	funcPtr = loadSymbol(gGlkLib, "gidispatch_count_functions", &errBuf);	217	funcPtr = loadSymbol(gGlkLib, "gidispatch_count_functions", &errBuf);
Lines 190-202 Link Here
190	fprintf(stderr, "%s\n", errBuf);	219	fprintf(stderr, "%s\n", errBuf);
191	exit(1);	220	exit(1);
192	}	221	}
		222	}
193		223
194	return (*funcPtr)();	224	return (*funcPtr)();
195	}	225	}
196		226
197	gidispatch_function_t *gidispatch_get_function(glui32 index)	227	gidispatch_function_t *gidispatch_get_function(glui32 index)
198	{	228	{
199	gidispatch_function_t * (*funcPtr)(glui32 index);	229	static gidispatch_function_t * (*funcPtr)(glui32 index);
		230
		231	if (! funcPtr) {
200	char * errBuf = NULL;	232	char * errBuf = NULL;
201		233
202	funcPtr = loadSymbol(gGlkLib, "gidispatch_get_function", &errBuf);	234	funcPtr = loadSymbol(gGlkLib, "gidispatch_get_function", &errBuf);
Lines 204-216 Link Here
204	fprintf(stderr, "%s\n", errBuf);	236	fprintf(stderr, "%s\n", errBuf);
205	exit(1);	237	exit(1);
206	}	238	}
		239	}
207		240
208	return (*funcPtr)(index);	241	return (*funcPtr)(index);
209	}	242	}
210		243
211	gidispatch_function_t *gidispatch_get_function_by_id(glui32 id)	244	gidispatch_function_t *gidispatch_get_function_by_id(glui32 id)
212	{	245	{
213	gidispatch_function_t * (*funcPtr)(glui32 id);	246	static gidispatch_function_t * (*funcPtr)(glui32 id);
		247
		248	if (! funcPtr) {
214	char * errBuf = NULL;	249	char * errBuf = NULL;
215		250
216	funcPtr = loadSymbol(gGlkLib, "gidispatch_get_function_by_id", &errBuf);	251	funcPtr = loadSymbol(gGlkLib, "gidispatch_get_function_by_id", &errBuf);
Lines 218-223 Link Here
218	fprintf(stderr, "%s\n", errBuf);	253	fprintf(stderr, "%s\n", errBuf);
219	exit(1);	254	exit(1);
220	}	255	}
		256	}
221		257
222	return (*funcPtr)(id);	258	return (*funcPtr)(id);
223	}	259	}

Lines 46-52 Link Here

(-)glkloader-0.3.2/unixfuncs.c~ (-2 / +8 lines)
46	strid_t glkunix_stream_open_pathname(char *pathname, glui32 textmode,	46	strid_t glkunix_stream_open_pathname(char *pathname, glui32 textmode,
47	glui32 rock)	47	glui32 rock)
48	{	48	{
49	strid_t (funcPtr)(char pathname, glui32 textmode, glui32 rock);	49	static strid_t (funcPtr)(char pathname, glui32 textmode, glui32 rock);
		50
		51	if (! funcPtr) {
50	char * errBuf = NULL;	52	char * errBuf = NULL;
51		53
52	funcPtr = loadSymbol(gGlkLib, "glkunix_stream_open_pathname", &errBuf);	54	funcPtr = loadSymbol(gGlkLib, "glkunix_stream_open_pathname", &errBuf);
Lines 54-66 Link Here
54	fprintf(stderr, "%s\n", errBuf);	56	fprintf(stderr, "%s\n", errBuf);
55	exit(1);	57	exit(1);
56	}	58	}
		59	}
57		60
58	return (*funcPtr)(pathname, textmode, rock);	61	return (*funcPtr)(pathname, textmode, rock);
59	}	62	}
60		63
61	void glkunix_set_base_file(char *filename)	64	void glkunix_set_base_file(char *filename)
62	{	65	{
63	void (funcPtr)(char filename);	66	static void (funcPtr)(char filename);
		67
		68	if (! funcPtr) {
64	char * errBuf = NULL;	69	char * errBuf = NULL;
65		70
66	funcPtr = loadSymbol(gGlkLib, "glkunix_set_base_file", &errBuf);	71	funcPtr = loadSymbol(gGlkLib, "glkunix_set_base_file", &errBuf);
Lines 68-73 Link Here
68	fprintf(stderr, "%s\n", errBuf);	73	fprintf(stderr, "%s\n", errBuf);
69	exit(1);	74	exit(1);
70	}	75	}
		76	}
71		77
72	(*funcPtr)(filename);	78	(*funcPtr)(filename);
73	}	79	}

Return to bug 116062