Debian Codegraph @

os2/rexx.c

raw
1 /*
2 * Copyright (C) 2004 Mark Hessling <[email protected]>
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
13 *
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the Free
16 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17 */
18
19 /*
20 * $Id: rexx.c,v 1.2 2004/06/06 11:14:01 mark Exp $
21 */
22 #if defined(HAVE_CONFIG_H)
23 # include "config.h"
24 #endif
25 #include "configur.h"
26
27 #include <stdio.h>
28
29 #define INCL_REXXSAA
30
31 #if defined(OS2)
32 # define INCL_DOSMODULEMGR
33 # define INCL_DOSMISC
34 # undef INCL_REXXSAA
35 # include <os2.h>
36 # define INCL_REXXSAA
37 # define DONT_TYPEDEF_PFN
38 # define DYNAMIC_OS2
39 #endif
40
41 #if defined(HAVE_ERRNO_H)
42 # include <errno.h>
43 #endif
44
45 #if defined(HAVE_MEMORY_H)
46 # include <memory.h>
47 #endif
48
49 #if defined(HAVE_STDARG_H)
50 # include <stdarg.h>
51 #endif
52
53 #if defined(HAVE_STDLIB_H)
54 # include <stdlib.h>
55 #endif
56
57 #undef __USE_BSD
58 #if defined(HAVE_STRING_H)
59 # include <string.h>
60 #endif
61
62 #if defined(HAVE_SYS_TYPES_H)
63 # include <sys/types.h>
64 #endif
65
66 #if defined(HAVE_SYS_STAT_H)
67 # include <sys/stat.h>
68 #endif
69
70 #if defined(HAVE_UNISTD_H)
71 # include <unistd.h>
72 #endif
73
74 #include "rexxsaa.h"
75
76 typedef HMODULE handle_type ;
77
78 #define FUNCTION_REXXSTART 0
79 #define FUNCTION_REXXVARIABLEPOOL 1
80 #define FUNCTION_REXXSETHALT 2
81 #define FUNCTION_REXXSETTRACE 3
82 #define FUNCTION_REXXRESETTRACE 4
83
84 #define NUM_REXX_FUNCTIONS 5
85
86 static char *MyFunctionName[ NUM_REXX_FUNCTIONS ] =
87 {
88 /* 0 */ "RexxStart",
89 /* 1 */ "RexxVariablePool",
90 /* 2 */ "RexxSetHalt",
91 /* 3 */ "RexxSetTrace",
92 /* 4 */ "RexxResetTrace",
93 };
94
95 /*
96 * Typedefs for Regina
97 */
98 typedef APIRET APIENTRY OREXXSTART(LONG,PRXSTRING,PSZ,PRXSTRING,PSZ,LONG,PRXSYSEXIT,PSHORT,PRXSTRING );
99 typedef APIRET APIENTRY OREXXVARIABLEPOOL(PSHVBLOCK );
100 typedef APIRET APIENTRY OREXXSETHALT(LONG,LONG );
101 typedef APIRET APIENTRY OREXXSETTRACE(LONG,LONG );
102 typedef APIRET APIENTRY OREXXRESETTRACE(LONG,LONG );
103 OREXXSTART *ORexxStart=NULL;
104 OREXXVARIABLEPOOL *ORexxVariablePool=NULL;
105 OREXXSETHALT *ORexxSetHalt=NULL;
106 OREXXSETTRACE *ORexxSetTrace=NULL;
107 OREXXRESETTRACE *ORexxResetTrace=NULL;
108
109 static char TraceFileName[256];
110 static int Trace = 0;
111 static int InterpreterIdx = -1;
112
113 static void TraceString( char *fmt, ... )
114 {
115 FILE *fp=NULL;
116 int using_stderr = 0;
117 va_list argptr;
118
119 if ( strcmp( TraceFileName, "stderr" ) == 0 )
120 using_stderr = 1;
121 if ( using_stderr )
122 fp = stderr;
123 else
124 fp = fopen( TraceFileName, "a" );
125 if ( fp )
126 {
127 va_start( argptr, fmt );
128 vfprintf( fp, fmt, argptr );
129 va_end( argptr );
130 if ( !using_stderr )
131 fclose( fp );
132 }
133 }
134
135 static handle_type FindInterpreter( char *library )
136 {
137 handle_type handle=(handle_type)NULL ;
138 CHAR LoadError[256];
139 PFN addr;
140 register int j=0;
141
142 if ( Trace )
143 {
144 TraceString( "%s: Attempting to load \"%s\" using DosLoadModule()...",
145 "FindInterpreter()",
146 "REGINA");
147 }
148 if ( DosLoadModule( LoadError, sizeof(LoadError), library, &handle ) )
149 {
150 handle = (handle_type)NULL;
151 }
152 if ( handle != (handle_type)NULL )
153 {
154 if ( Trace )
155 {
156 TraceString( "found REGINA\n" );
157 }
158 for ( j = 0; j < NUM_REXX_FUNCTIONS; j++ )
159 {
160 if ( DosQueryProcAddr( handle, 0L, MyFunctionName[j], &addr) )
161 {
162 addr = NULL;
163 }
164 /*
165 * Log the function and address. This is useful if the module
166 * doesn't have an address for this procedure.
167 */
168 if (Trace)
169 {
170 TraceString( "%s: Address %x\n",
171 MyFunctionName[j],
172 (addr == NULL) ? 0 : addr );
173 }
174 /*
175 * Even if the function being processed is not in the module, its
176 * address is still stored. In this case it will simply be set
177 * again to NULL.
178 */
179 switch ( j )
180 {
181 case FUNCTION_REXXSTART: ORexxStart = (OREXXSTART *)addr; break;
182 case FUNCTION_REXXVARIABLEPOOL: ORexxVariablePool = (OREXXVARIABLEPOOL *)addr; break;
183 case FUNCTION_REXXSETHALT: ORexxSetHalt= (OREXXSETHALT *)addr; break;
184 case FUNCTION_REXXSETTRACE: ORexxSetTrace = (OREXXSETTRACE *)addr; break;
185 case FUNCTION_REXXRESETTRACE: ORexxResetTrace = (OREXXRESETTRACE *)addr; break;
186 }
187 }
188 }
189 else
190 {
191 if ( Trace )
192 {
193 TraceString( "not found: %s\n", LoadError );
194 }
195 }
196 return handle;
197 }
198
199 static void LoadInterpreter( void )
200 {
201 handle_type handle=(handle_type)NULL ;
202 char *ptr;
203
204 if ( DosScanEnv( "REXX_TRACEFILE", (PSZ *)&ptr ) )
205 ptr = NULL;
206 if ( ptr != NULL )
207 {
208 Trace = 1;
209 strcpy( TraceFileName, ptr );
210 }
211
212 handle = (handle_type)FindInterpreter( "REGINA" );
213 if ( handle == (handle_type)NULL )
214 {
215 fprintf( stderr, "Could not find Regina DLL. Cannot continue.\n" );
216 exit( 11 );
217 }
218 if ( Trace )
219 {
220 TraceString( "----------- Initialisation Complete - Program Execution Begins -----------\n" );
221 }
222 InterpreterIdx = 0;
223 return;
224 }
225
226
227 /*
228 * RexxStart
229 */
230 APIRET APIENTRY RexxStart(
231 LONG ArgCount,
232 PRXSTRING ArgList,
233 PCSZ ProgramName,
234 PRXSTRING Instore,
235 PCSZ EnvName,
236 LONG CallType,
237 PRXSYSEXIT Exits,
238 PSHORT ReturnCode,
239 PRXSTRING Result )
240 {
241 APIRET rc=RXFUNC_NOTREG;
242
243 if ( InterpreterIdx == -1 )
244 LoadInterpreter();
245
246 if (Trace)
247 {
248 TraceString( "%s: ArgCount: %d ArgList: %x ProgramName: \"%s\" Instore: %x EnvName: \"%s\" Calltype: %d Exits: %x ReturnCode: %x Result: %x",
249 "RexxStart()",
250 ArgCount,
251 ArgList,
252 ProgramName,
253 Instore,
254 EnvName,
255 CallType,
256 Exits,
257 ReturnCode,
258 Result );
259 }
260 if (ORexxStart)
261 rc = (*ORexxStart)(
262 (LONG) ArgCount,
263 (PRXSTRING) ArgList,
264 (PSZ) ProgramName,
265 (PRXSTRING) Instore,
266 (PSZ) EnvName,
267 (LONG) CallType,
268 (PRXSYSEXIT)Exits,
269 (PSHORT) ReturnCode,
270 (PRXSTRING) Result ) ;
271 if (Trace)
272 {
273 TraceString( "<=> ReturnCode %d ResultString \"%s\" Result: %d\n",
274 (Result && Result->strptr) ? Result->strptr : "",
275 ReturnCode,
276 rc );
277 }
278 return rc;
279 }
280
281 /*
282 * Variable pool
283 */
284 APIRET APIENTRY RexxVariablePool(
285 PSHVBLOCK RequestBlockList )
286 {
287 APIRET rc=RXSHV_NOAVL;
288
289 if ( InterpreterIdx == -1 )
290 LoadInterpreter();
291
292 if (Trace)
293 {
294 PSHVBLOCK tmp=RequestBlockList;
295 TraceString( "%s: RequestBlockList %x\n",
296 "RexxVariablePool()",
297 RequestBlockList );
298 while(tmp)
299 {
300 switch( tmp->shvcode )
301 {
302 case RXSHV_SET:
303 TraceString("in RXSHV_SET: shvname: \"%s\" shvnamelen: %d shvvalue: \"%s\" shvvaluelen: %d\n",
304 tmp->shvname.strptr, tmp->shvnamelen, tmp->shvvalue.strptr, tmp->shvvaluelen );
305 break;
306 case RXSHV_SYSET:
307 TraceString("in RXSHV_SYSET: shvname: \"%s\" shvnamelen: %d shvvalue: \"%s\" shvvaluelen: %d\n",
308 tmp->shvname.strptr, tmp->shvnamelen, tmp->shvvalue.strptr, tmp->shvvaluelen );
309 break;
310 case RXSHV_FETCH:
311 TraceString("in RXSHV_FETCH: shvname: \"%s\" shvnamelen: %d\n",
312 tmp->shvname.strptr, tmp->shvnamelen );
313 break;
314 case RXSHV_DROPV:
315 TraceString("in RXSHV_DROPV: shvname: \"%s\" shvnamelen: %d\n",
316 tmp->shvname.strptr, tmp->shvnamelen );
317 break;
318 case RXSHV_SYDRO:
319 TraceString("in RXSHV_SYDRO: shvname: \"%s\" shvnamelen: %d\n",
320 tmp->shvname.strptr, tmp->shvnamelen );
321 break;
322 case RXSHV_NEXTV:
323 TraceString("in RXSHV_NEXTV: shvname: \"%s\" shvnamelen: %d\n",
324 tmp->shvname.strptr, tmp->shvnamelen );
325 break;
326 case RXSHV_PRIV:
327 TraceString("in RXSHV_PRIV\n" );
328 break;
329 case RXSHV_EXIT:
330 TraceString("in RXSHV_EXIT\n" );
331 break;
332 default:
333 break;
334 }
335 tmp = tmp->shvnext;
336 }
337 }
338 if (ORexxVariablePool)
339 rc = (*ORexxVariablePool)(
340 (PSHVBLOCK) RequestBlockList);
341 if (Trace)
342 {
343 PSHVBLOCK tmp=RequestBlockList;
344 while(tmp)
345 {
346 switch( tmp->shvcode )
347 {
348 case RXSHV_SET:
349 TraceString("out RXSHV_SET: shvret: %x\n",
350 tmp->shvret );
351 break;
352 case RXSHV_SYSET:
353 TraceString("out RXSHV_SYSET: shvret: %x\n",
354 tmp->shvret );
355 break;
356 case RXSHV_FETCH:
357 TraceString("out RXSHV_FETCH: shvret: %x shvvalue: \"%s\" shvvaluelen: %d\n",
358 tmp->shvret, tmp->shvvalue.strptr, tmp->shvvaluelen );
359 break;
360 case RXSHV_DROPV:
361 TraceString("out RXSHV_DROPV: shvret: %x\n",
362 tmp->shvret );
363 break;
364 case RXSHV_SYDRO:
365 TraceString("out RXSHV_SYDRO: shvret: %x\n",
366 tmp->shvret );
367 break;
368 case RXSHV_NEXTV:
369 TraceString("out RXSHV_NEXTV: shvret: %x\n",
370 tmp->shvret );
371 break;
372 case RXSHV_PRIV:
373 TraceString("out RXSHV_PRIV: shvret: %x\n",
374 tmp->shvret );
375 break;
376 case RXSHV_EXIT:
377 TraceString("out RXSHV_EXIT: shvret: %x\n",
378 tmp->shvret );
379 break;
380 default:
381 break;
382 }
383 tmp = tmp->shvnext;
384 }
385 TraceString( "<=> Result: %d\n", rc );
386 }
387 return rc;
388 }
389
390 /* ============================================================= */
391 /* Asynchronous Request Rexx API interface */
392
393 APIRET APIENTRY RexxSetHalt( LONG pid,
394 LONG tid)
395 {
396 APIRET rc=RXARI_NOT_FOUND;
397
398 if ( InterpreterIdx == -1 )
399 LoadInterpreter();
400
401 if (Trace)
402 {
403 TraceString( "%s: pid: %ld tid: %ld ",
404 "RexxSetHalt()",
405 pid,
406 tid );
407
408 }
409 if (ORexxSetHalt)
410 {
411 rc = (*ORexxSetHalt)(
412 (LONG) pid,
413 (LONG) tid);
414 }
415 if (Trace)
416 {
417 TraceString( "<=> Result: %d\n", rc );
418 }
419 return rc;
420 }
421
422 APIRET APIENTRY RexxSetTrace( LONG pid,
423 LONG tid)
424 {
425 APIRET rc=RXARI_NOT_FOUND;
426
427 if ( InterpreterIdx == -1 )
428 LoadInterpreter();
429
430 if (Trace)
431 {
432 TraceString( "%s: pid: %ld tid: %ld ",
433 "RexxSetTrace()",
434 pid,
435 tid );
436
437 }
438 if (ORexxSetTrace)
439 {
440 rc = (*ORexxSetTrace)(
441 (LONG) pid,
442 (LONG) tid);
443 }
444 if (Trace)
445 {
446 TraceString( "<=> Result: %d\n", rc );
447 }
448 return rc;
449 }
450
451 APIRET APIENTRY RexxResetTrace( LONG pid,
452 LONG tid)
453 {
454 APIRET rc=RXARI_NOT_FOUND;
455
456 if ( InterpreterIdx == -1 )
457 LoadInterpreter();
458
459 if (Trace)
460 {
461 TraceString( "%s: pid: %ld tid: %ld ",
462 "RexxResetTrace()",
463 pid,
464 tid );
465
466 }
467 if (ORexxResetTrace)
468 {
469 rc = (*ORexxResetTrace)(
470 (LONG) pid,
471 (LONG) tid);
472 }
473 if (Trace)
474 {
475 TraceString( "<=> Result: %d\n", rc );
476 }
477 return rc;
478 }
479
480 /*
481 * The following functions do nothing; they are here because they are exported in the DLL
482 */
483 APIRET APIENTRY RxBreakCleanup(
484 VOID )
485 {
486 APIRET rc=0;
487
488 if ( InterpreterIdx == -1 )
489 LoadInterpreter();
490
491 if (Trace)
492 {
493 TraceString( "%s: ",
494 "RxBreakCleanup()" );
495
496 }
497 if (Trace)
498 {
499 TraceString( "<=> Result: %d\n",
500 rc );
501 }
502 return rc;
503 }
504
505 APIRET APIENTRY RexxSAA(
506 VOID )
507 {
508 APIRET rc=0;
509
510 if ( InterpreterIdx == -1 )
511 LoadInterpreter();
512
513 if (Trace)
514 {
515 TraceString( "%s: ",
516 "RexxSAA()" );
517
518 }
519 if (Trace)
520 {
521 TraceString( "<=> Result: %d\n",
522 rc );
523 }
524 return rc;
525 }