Debian Codegraph @

execiser.c

raw
1 #include <stdio.h>
2 #include <string.h>
3 #include <stdlib.h>
4
5 #define INCL_RXSHV
6 #define INCL_RXFUNC
7 #define INCL_RXSYSEXIT
8 #define INCL_RXSUBCOM
9 #define INCL_RXQUEUE
10
11 #include "rexxsaa.h"
12
13 #define STARTUPMSG " +++ Interactive trace. \"Trace Off\" to end debug. ENTER to continue."
14
15 #ifdef _MSC_VER
16 /* This picky compiler claims about unused formal parameters.
17 * This is correct but hides (for human eyes) other errors since they
18 * are many and we can't reduce them all.
19 * Error 4100 is "unused formal parameter".
20 */
21 # pragma warning(disable:4100)
22 #endif
23
24 static void message( char *msg )
25 {
26 printf( " %s", msg ) ;
27 fflush(stdout) ;
28 }
29
30
31 static void mycomplain( char *msg )
32 {
33 fprintf( stderr, "Complaint: %s\n", msg ) ;
34 }
35
36 static void iverify( char *msg, int first, int second )
37 {
38 if (first != second)
39 printf( "\nInt verify: %s: %d ^= %d\n", msg, first, second ) ;
40 }
41
42 static void sverify( char *msg, PRXSTRING first, char *second )
43 {
44 if (!second)
45 {
46 if (first->strptr)
47 printf( "\nSecond is null, first: %d<%s>\n", (int) first->strlength,
48 first->strptr ) ;
49 }
50 else if (strlen(second) != first->strlength)
51 {
52 printf( "\nString length: %s: %d ^=%d\n", msg,
53 (int) first->strlength, (int) strlen(second)) ;
54 printf( " first=%4d<%s>\n", (int) first->strlength, first->strptr ) ;
55 printf( " secnd=%4d<%s>\n", (int) strlen(second), second ) ;
56 }
57 else
58 if (memcmp(second, first->strptr, first->strlength))
59 printf( "\nString contents: %s: <%s> ^== <%s>\n", msg,
60 first->strptr, second ) ;
61 }
62
63
64
65
66 LONG APIENTRY instore_exit( LONG ExNum, LONG Subfun, PEXIT PBlock )
67 {
68 RXSIOSAY_PARM *psiosay;
69 iverify( "Exitfunction", ExNum, RXSIO ) ;
70 iverify( "Subfunction", Subfun, RXSIOSAY ) ;
71 psiosay = (RXSIOSAY_PARM *)PBlock;
72 sverify( "Exit string", &(psiosay->rxsio_string), "foobar" ) ;
73
74 return RXEXIT_HANDLED ;
75 }
76
77 static void instore( void )
78 {
79 RXSTRING Instore[2] ;
80 RXSYSEXIT Exits[2] ;
81 int rc ;
82
83 message( "instore" ) ;
84
85 RexxRegisterExitExe( "Foo", instore_exit, NULL ) ;
86
87 Exits[0].sysexit_name = "Foo" ;
88 Exits[0].sysexit_code = RXSIO ;
89 Exits[1].sysexit_code = RXENDLST ;
90
91 Instore[0].strptr = "say 'foobar'" ;
92 Instore[0].strlength = strlen( Instore[0].strptr ) ;
93 Instore[1].strptr = NULL ;
94 rc = RexxStart( 0, NULL, "Testing", Instore, "Foo", RXCOMMAND,
95 Exits, NULL, NULL ) ;
96
97 rc = RexxStart( 0, NULL, "Testing", Instore, "", RXCOMMAND,
98 Exits, NULL, NULL ) ;
99
100 Instore[0].strptr = NULL ;
101 rc = RexxStart( 0, NULL, "Testing", Instore, "", RXCOMMAND,
102 Exits, NULL, NULL ) ;
103
104 rc = RexxStart( 0, NULL, "Testing", Instore, "", RXCOMMAND,
105 Exits, NULL, NULL ) ;
106
107 RexxFreeMemory( Instore[1].strptr ) ;
108 RexxDeregisterExit( "Foo", NULL ) ;
109 }
110
111
112 LONG APIENTRY trace_exit( LONG ExNum, LONG Subfun, PEXIT PBlock )
113 {
114 char tmp[200];
115 RXSIOTRC_PARM *psiotrc;
116 iverify( "Exitfunction", ExNum, RXSIO ) ;
117 if (Subfun==RXSIOTRC)
118 {
119 psiotrc = (RXSIOTRC_PARM *)PBlock;
120 sverify( "Exit string", &(psiotrc->rxsio_string),
121 " 1 *-* trace off" ) ;
122 }
123 else
124 {
125 sprintf( tmp, "Unexpected subfunction, got %ld\n", Subfun ) ;
126 mycomplain( tmp );
127 }
128
129 return RXEXIT_HANDLED ;
130 }
131
132 static void trace( void )
133 {
134 RXSTRING Instore[2] ;
135 RXSYSEXIT Exits[2] ;
136 int rc ;
137
138 message( "trace" ) ;
139
140 RexxRegisterExitExe( "Foo", trace_exit, NULL ) ;
141
142 Exits[0].sysexit_name = "Foo" ;
143 Exits[0].sysexit_code = RXSIO ;
144 Exits[1].sysexit_code = RXENDLST ;
145
146 Instore[0].strptr = "trace all;trace off" ;
147 Instore[0].strlength = strlen( Instore[0].strptr ) ;
148 Instore[1].strptr = NULL ;
149
150 rc = RexxStart( 0, NULL, "Testing", Instore, "Foo", RXCOMMAND,
151 Exits, NULL, NULL ) ;
152
153 RexxDeregisterExit( "Foo", NULL ) ;
154 }
155
156 static void assign_new_rxstring( PRXSTRING dest, const char *source )
157 {
158 int len;
159 char *buf;
160
161 len = strlen( source );
162 if ( ( buf = (char *)RexxAllocateMemory( len + 1 ) ) == NULL )
163 {
164 fprintf( stderr, "RexxAllocateMemory returns NULL.\n" );
165 exit( 1 );
166 }
167 strcpy( buf, source );
168 MAKERXSTRING( *dest, buf, len );
169
170 }
171
172 LONG APIENTRY intertrc_exit( LONG ExNum, LONG Subfun, PEXIT PBlock )
173 {
174 static int cnt=0 ;
175 static char *data[] = {
176 "",
177 " 2 *-* say 'hallo'",
178 " >L> \"hallo\"",
179 "hallo",
180 STARTUPMSG,
181 "=",
182 " *-* say 'hallo'",
183 " >L> \"hallo\"",
184 "hallo",
185 "",
186 " *-* trace off",
187 "",
188 };
189 RXSIOTRC_PARM *psiotrc;
190 RXSIOSAY_PARM *psiosay;
191 RXSIODTR_PARM *psiodtr;
192
193 iverify( "Exitfunction", ExNum, RXSIO ) ;
194 switch (++cnt)
195 {
196 case 1:
197 case 2:
198 case 4:
199 case 6:
200 case 7:
201 case 10:
202 case 11:
203 iverify( "Subfunction", Subfun, RXSIOTRC ) ;
204 psiotrc = (RXSIOTRC_PARM *)PBlock;
205 sverify( "Trace output", &(psiotrc->rxsio_string),data[cnt]);
206 break ;
207
208 case 3:
209 case 8:
210 iverify( "Subfunction", Subfun, RXSIOSAY ) ;
211 psiosay = (RXSIOSAY_PARM *)PBlock;
212 sverify( "Say output", &(psiosay->rxsio_string), data[cnt]);
213 break ;
214
215 case 5:
216 case 9:
217 iverify( "Subfunction", Subfun, RXSIODTR ) ;
218 psiodtr = (RXSIODTR_PARM *)PBlock;
219 assign_new_rxstring( &psiodtr->rxsiodtr_retc, data[cnt] );
220 break ;
221
222 default:
223 fprintf( stderr, "Out of order msg subfunc=%ld\n", Subfun) ;
224 return RXEXIT_NOT_HANDLED ;
225 }
226 return RXEXIT_HANDLED ;
227 }
228
229 static void intertrc( void )
230 {
231 RXSTRING Instore[2] ;
232 RXSYSEXIT Exits[2] ;
233 int rc ;
234
235 message( "intertrc" ) ;
236
237 RexxRegisterExitExe( "Foo", intertrc_exit, NULL ) ;
238
239 Exits[0].sysexit_name = "Foo" ;
240 Exits[0].sysexit_code = RXSIO ;
241 Exits[1].sysexit_code = RXENDLST ;
242
243 Instore[0].strptr = "trace ?int\nsay 'hallo'; trace off" ;
244 Instore[0].strlength = strlen( Instore[0].strptr ) ;
245 Instore[1].strptr = NULL ;
246
247 rc = RexxStart( 0, NULL, "Testing", Instore, "Foo", RXCOMMAND,
248 Exits, NULL, NULL ) ;
249
250 RexxDeregisterExit( "Foo", NULL ) ;
251 }
252
253
254
255
256
257 LONG APIENTRY pull_exit( LONG ExNum, LONG Subfun, PEXIT PBlock )
258 {
259 static int cnt=0 ;
260 static char *data[] = {
261 "",
262 "alpha",
263 "ALPHA",
264 "FOO",
265 "beta",
266 "beta",
267 };
268 RXSIOSAY_PARM *psiosay;
269 RXSIOTRD_PARM *psiotrd;
270
271 iverify( "Exitfunction", ExNum, RXSIO ) ;
272 switch (++cnt)
273 {
274 case 2:
275 case 3:
276 case 5:
277 iverify( "Subfunction", Subfun, RXSIOSAY ) ;
278 psiosay = (RXSIOSAY_PARM *)PBlock;
279 sverify( "Trace output", &(psiosay->rxsio_string),data[cnt]);
280 break ;
281
282 case 1:
283 case 4:
284 iverify( "Subfunction", Subfun, RXSIOTRD ) ;
285 psiotrd = (RXSIOTRD_PARM *)PBlock;
286 assign_new_rxstring( &psiotrd->rxsiotrd_retc, data[cnt] );
287 break ;
288
289 default:
290 fprintf( stderr, "Out of order msg subfunc=%ld\n", Subfun) ;
291 return RXEXIT_NOT_HANDLED ;
292 }
293 return RXEXIT_HANDLED ;
294 }
295
296 static void pull( void )
297 {
298 RXSTRING Instore[2] ;
299 RXSYSEXIT Exits[2] ;
300 int rc ;
301
302 message( "pull" ) ;
303
304 RexxRegisterExitExe( "Foo", pull_exit, NULL ) ;
305
306 Exits[0].sysexit_name = "Foo" ;
307 Exits[0].sysexit_code = RXSIO ;
308 Exits[1].sysexit_code = RXENDLST ;
309
310 Instore[0].strptr =
311 "pull bar;say bar;push 'foo';pull bar;say bar;parse pull bar;say bar" ;
312 Instore[0].strlength = strlen( Instore[0].strptr ) ;
313 Instore[1].strptr = NULL ;
314
315 rc = RexxStart( 0, NULL, "Testing", Instore, "Foo", RXCOMMAND,
316 Exits, NULL, NULL ) ;
317
318 RexxDeregisterExit( "Foo", NULL ) ;
319 }
320
321
322 LONG APIENTRY env_exit( LONG ExNum, LONG Subfun, PEXIT PBlock )
323 {
324 static int cnt=0 ;
325 static char data[10];
326 RXENVGET_PARM *penvget;
327 RXENVSET_PARM *penvset;
328
329 iverify( "Exitfunction", ExNum, RXENV ) ;
330 switch (++cnt)
331 {
332 case 1:
333 iverify( "Subfunction", Subfun, RXENVGET ) ;
334 penvget = (RXENVGET_PARM *)PBlock;
335 sverify( "Envget name", &(penvget->rxenv_name),"FRED");
336 assign_new_rxstring( &penvget->rxenv_value, "initial" );
337 break ;
338
339 case 2:
340 iverify( "Subfunction", Subfun, RXENVSET ) ;
341 penvset = (RXENVSET_PARM *)PBlock;
342 sverify( "Envset name", &(penvset->rxenv_name),"FRED");
343 sverify( "Envset value", &(penvset->rxenv_value),"junk");
344 strcpy( data, "mess" );
345 break ;
346
347 case 3:
348 iverify( "Subfunction", Subfun, RXENVGET ) ;
349 penvget = (RXENVGET_PARM *)PBlock;
350 sverify( "Envget name", &(penvget->rxenv_name),"FRED");
351 assign_new_rxstring( &penvget->rxenv_value, data );
352 break ;
353
354 default:
355 fprintf( stderr, "Out of order msg subfunc=%ld\n", Subfun) ;
356 return RXEXIT_NOT_HANDLED ;
357 }
358 return RXEXIT_HANDLED ;
359 }
360
361 static void env( void )
362 {
363 RXSTRING Instore[2] ;
364 RXSYSEXIT Exits[2] ;
365 int rc ;
366
367 message( "env") ;
368
369 RexxRegisterExitExe( "Foo", env_exit, NULL ) ;
370
371 Exits[0].sysexit_name = "Foo" ;
372 Exits[0].sysexit_code = RXENV ;
373 Exits[1].sysexit_code = RXENDLST ;
374
375 Instore[0].strptr =
376 "call value 'FRED', 'junk', 'ENVIRONMENT'; if value('FRED',,'ENVIRONMENT') <> 'mess' then say 'setenv/getenv failed'" ;
377 Instore[0].strlength = strlen( Instore[0].strptr ) ;
378 Instore[1].strptr = NULL ;
379
380 rc = RexxStart( 0, NULL, "Testing", Instore, "Foo", RXCOMMAND,
381 Exits, NULL, NULL ) ;
382
383 RexxDeregisterExit( "Foo", NULL ) ;
384 }
385
386
387
388
389 LONG APIENTRY query_init_exit( LONG ExNum, LONG Subfun, PEXIT PBlock )
390 {
391 char *name="TEST1" ;
392 int rc ;
393 char result[100];
394 ULONG dup;
395 RXSTRING data;
396
397 data.strptr = result;
398 rc = RexxCreateQueue( result, sizeof(result), name, &dup ) ;
399 iverify( "Query Init exit", rc, RXQUEUE_OK ) ;
400 data.strlength = strlen(result);
401 sverify( "Query Init exit", &data, name ) ;
402 iverify( "Query Init dup", dup, 0L ) ;
403
404 data.strptr = "line1";
405 data.strlength = strlen(data.strptr);
406 rc = RexxAddQueue( name, &data, RXQUEUE_FIFO ) ;
407 iverify( "Query Init exit", rc, RXQUEUE_OK ) ;
408
409 data.strptr = "line2";
410 data.strlength = strlen(data.strptr);
411 rc = RexxAddQueue( name, &data, RXQUEUE_FIFO ) ;
412 iverify( "Query Init exit", rc, RXQUEUE_OK ) ;
413
414 return RXEXIT_HANDLED ;
415 }
416
417 LONG APIENTRY query_term_exit( LONG ExNum, LONG Subfun, PEXIT PBlock )
418 {
419 int rc ;
420 ULONG count;
421 RXSTRING data;
422 DATETIME timestamp;
423
424 rc = RexxQueryQueue( "FRED", &count ) ;
425 iverify( "Query Term exit", rc, RXQUEUE_OK ) ;
426 iverify( "Query Term count", count, 2L ) ;
427
428 data.strptr = NULL;
429 rc = RexxPullQueue( "FRED", &data, &timestamp, RXQUEUE_NOWAIT );
430 iverify( "Query Term exit", rc, RXQUEUE_OK ) ;
431 sverify( "Query Term data", &data, "2line" ) ;
432 RexxFreeMemory( data.strptr ) ;
433
434 data.strptr = NULL;
435 rc = RexxPullQueue( "FRED", &data, &timestamp, RXQUEUE_NOWAIT );
436 iverify( "Query Term exit", rc, RXQUEUE_OK ) ;
437 sverify( "Query Term data", &data, "1line" ) ;
438 RexxFreeMemory( data.strptr ) ;
439
440 rc = RexxDeleteQueue( "FRED" );
441 iverify( "Query Term exit", rc, RXQUEUE_OK ) ;
442
443 rc = RexxDeleteQueue( "TEST1" );
444 iverify( "Query Term exit", rc, RXQUEUE_OK ) ;
445
446 return RXEXIT_HANDLED ;
447 }
448
449 LONG APIENTRY it_init_exit( LONG ExNum, LONG Subfun, PEXIT PBlock )
450 {
451 SHVBLOCK shv ;
452 char *name="FOO" ;
453 int rc ;
454 char *value="foz" ;
455
456 shv.shvnext = NULL ;
457 shv.shvname.strptr = name ;
458 shv.shvnamelen = shv.shvname.strlength = strlen(name) ;
459 shv.shvvalue.strptr = value ;
460 shv.shvvaluelen = shv.shvvalue.strlength = strlen(value) ;
461 shv.shvcode = RXSHV_SYSET ;
462
463 rc = RexxVariablePool( &shv ) ;
464 iverify( "Init exit", rc, RXSHV_NEWV ) ;
465 iverify( "Init exit", shv.shvret, RXSHV_NEWV ) ;
466 return RXEXIT_HANDLED ;
467 }
468
469
470 LONG APIENTRY it_term_exit( LONG ExNum, LONG Subfun, PEXIT PBlock )
471 {
472 SHVBLOCK shv ;
473 char *name ;
474 int rc ;
475 char value[64] ;
476
477 strcpy( value, "" ) ;
478 shv.shvnext = NULL ;
479 name = "MYVAR" ;
480 shv.shvname.strptr = name ;
481 shv.shvnamelen = shv.shvname.strlength = strlen(name) ;
482 shv.shvvalue.strptr = value ;
483 shv.shvvaluelen = 64 ;
484 shv.shvcode = RXSHV_SYFET ;
485
486 rc = RexxVariablePool( &shv ) ;
487 iverify( "Term exit", rc, RXSHV_NEWV ) ;
488 iverify( "Term exit", shv.shvret, RXSHV_NEWV ) ;
489 sverify( "Term exit:", &(shv.shvvalue), "MYVAR" ) ;
490
491 shv.shvnext = NULL ;
492 name = "bar" ;
493 shv.shvname.strptr = name ;
494 shv.shvnamelen = shv.shvname.strlength = strlen(name) ;
495
496 /* The value is the same as above (value) and therefore valid */
497 #if 0
498 shv.shvvalue.strptr = value ;
499 shv.shvvaluelen = 64 ;
500 shv.shvvalue.strlength = strlen(value) ; /* not allowed! not 0-terminated */
501 #endif
502 shv.shvcode = RXSHV_SYFET ;
503
504 rc = RexxVariablePool( &shv ) ;
505 iverify( "Term exit", rc, RXSHV_OK ) ;
506 iverify( "Term exit", shv.shvret, RXSHV_OK ) ;
507 sverify( "Term exit:", &(shv.shvvalue), "baz" ) ;
508
509 return RXEXIT_HANDLED ;
510 }
511
512
513 LONG APIENTRY it_say_exit( LONG ExNum, LONG Subfun, PEXIT PBlock )
514 {
515 SHVBLOCK shv ;
516 char *name ;
517 int rc ;
518 char value[64] ;
519 RXSIOSAY_PARM *psiosay;
520
521 iverify( "Say exit", ExNum, RXSIO ) ;
522 iverify( "Say exit", Subfun, RXSIOSAY ) ;
523 psiosay = (RXSIOSAY_PARM *)PBlock;
524 sverify( "Say exit", &(psiosay->rxsio_string), "foz" ) ;
525
526 shv.shvnext = NULL ;
527 name = "myvar.1" ;
528 shv.shvname.strptr = name ;
529 shv.shvnamelen = shv.shvname.strlength = strlen(name) ;
530 shv.shvvalue.strptr = value ;
531 shv.shvvaluelen = 64 ;
532 shv.shvcode = RXSHV_SYFET ;
533
534 rc = RexxVariablePool( &shv ) ;
535 iverify( "Say exit", rc, RXSHV_NEWV ) ;
536 iverify( "Say exit", shv.shvret, RXSHV_NEWV ) ;
537 sverify( "Say exit:", &(shv.shvvalue), "MYVAR.1" ) ;
538
539 return RXEXIT_HANDLED ;
540 }
541
542 LONG APIENTRY its_init_exit( LONG ExNum, LONG Subfun, PEXIT PBlock )
543 {
544 SHVBLOCK shv ;
545 char *name="FOO" ;
546 int rc ;
547 char *value="foz" ;
548
549 shv.shvnext = NULL ;
550 shv.shvname.strptr = name ;
551 shv.shvnamelen = shv.shvname.strlength = strlen(name) ;
552 shv.shvvalue.strptr = value ;
553 shv.shvvaluelen = shv.shvvalue.strlength = strlen(value) ;
554 shv.shvcode = RXSHV_SYSET ;
555
556 rc = RexxVariablePool( &shv ) ;
557 iverify( "Init exit", rc, RXSHV_NEWV ) ;
558 iverify( "Init exit", shv.shvret, RXSHV_NEWV ) ;
559 fprintf( stdout, "in RXINI exit handler; setting FOO=foz\n" );
560 return RXEXIT_HANDLED ;
561 }
562
563
564 LONG APIENTRY its_term_exit( LONG ExNum, LONG Subfun, PEXIT PBlock )
565 {
566 SHVBLOCK shv ;
567 char *name ;
568 int rc ;
569 char value[100] ;
570
571 strcpy( value, "" ) ;
572 shv.shvnext = NULL ;
573 name = "MYVAR" ;
574 shv.shvname.strptr = name ;
575 shv.shvnamelen = shv.shvname.strlength = strlen(name) ;
576 shv.shvvalue.strptr = value ;
577 shv.shvvaluelen = sizeof( value );
578 shv.shvcode = RXSHV_SYFET ;
579
580 rc = RexxVariablePool( &shv ) ;
581 iverify( "Term exit", rc, RXSHV_NEWV ) ;
582 iverify( "Term exit", shv.shvret, RXSHV_NEWV ) ;
583 sverify( "Term exit:", &(shv.shvvalue), "MYVAR" ) ;
584
585 shv.shvnext = NULL ;
586 name = "bar" ;
587 shv.shvname.strptr = name ;
588 shv.shvnamelen = shv.shvname.strlength = strlen(name) ;
589
590 /* The value is the same as above (value) and therefore valid */
591 #if 0
592 shv.shvvalue.strptr = value ;
593 shv.shvvaluelen = sizeof( value ) ;
594 shv.shvvalue.strlength = strlen(value) ; /* not allowed! not 0-terminated */
595 #endif
596 shv.shvcode = RXSHV_SYFET ;
597
598 rc = RexxVariablePool( &shv ) ;
599 iverify( "Term exit", rc, RXSHV_OK ) ;
600 iverify( "Term exit", shv.shvret, RXSHV_OK ) ;
601 sverify( "Term exit:", &(shv.shvvalue), "baz" ) ;
602 fprintf( stdout, "in RXTER exit handler; value of BAR variable should be 'baz'; it is %s\n", shv.shvvalue.strptr );
603
604 /* get some private variables from the interpreter */
605 shv.shvnext = NULL;
606 shv.shvcode = RXSHV_PRIV;
607 shv.shvname.strptr = "VERSION" ;
608 shv.shvname.strlength = 7;
609 shv.shvnamelen = shv.shvname.strlength ;
610 shv.shvvalue.strptr = value;
611 shv.shvvalue.strlength = sizeof( value );
612 shv.shvvaluelen = shv.shvvalue.strlength ;
613 rc = RexxVariablePool( &shv ); /* get the next variable */
614 iverify( "Term exit", rc, RXSHV_OK ) ;
615 iverify( "Term exit", shv.shvret, RXSHV_OK ) ;
616 fprintf( stdout, "\nin RXTER exit handler; Regina's version (via RXSHV_PRIV is %s\n", shv.shvvalue.strptr );
617
618 return RXEXIT_HANDLED ;
619 }
620
621 static void init_term(void)
622 {
623 RXSTRING Instore[2] ;
624 RXSYSEXIT Exits[4] ;
625 int rc ;
626
627 message( "init/term" ) ;
628
629 RexxRegisterExitExe( "init", it_init_exit, NULL ) ;
630 RexxRegisterExitExe( "term", it_term_exit, NULL ) ;
631 RexxRegisterExitExe( "say", it_say_exit, NULL ) ;
632
633 Exits[0].sysexit_name = "init" ;
634 Exits[0].sysexit_code = RXINI ;
635 Exits[1].sysexit_name = "term" ;
636 Exits[1].sysexit_code = RXTER ;
637 Exits[2].sysexit_name = "say" ;
638 Exits[2].sysexit_code = RXSIO ;
639 Exits[3].sysexit_code = RXENDLST ;
640
641 Instore[0].strptr =
642 "say foo\n\n\nbar='baz'\nexit" ;
643 Instore[0].strlength = strlen( Instore[0].strptr ) ;
644 Instore[1].strptr = NULL ;
645
646 rc = RexxStart( 0, NULL, "Testing", Instore, "Foo", RXCOMMAND,
647 Exits, NULL, NULL ) ;
648
649 RexxDeregisterExit( "init", NULL ) ;
650 RexxDeregisterExit( "term", NULL ) ;
651 RexxDeregisterExit( "say", NULL ) ;
652 }
653
654 static void init_term_show(void)
655 {
656 RXSTRING Instore[2] ;
657 RXSYSEXIT Exits[3] ;
658 int rc ;
659
660 fprintf( stdout, "init/term exits:\n" ) ;
661
662 RexxRegisterExitExe( "init", its_init_exit, NULL ) ;
663 RexxRegisterExitExe( "term", its_term_exit, NULL ) ;
664
665 Exits[0].sysexit_name = "init" ;
666 Exits[0].sysexit_code = RXINI ;
667 Exits[1].sysexit_name = "term" ;
668 Exits[1].sysexit_code = RXTER ;
669 Exits[2].sysexit_code = RXENDLST ;
670
671 Instore[0].strptr =
672 "say 'in instore program'\nsay 'FOO should be foz; it is:'foo 'and setting BAR=baz'\n\nbar='baz'\nexit" ;
673 Instore[0].strlength = strlen( Instore[0].strptr ) ;
674 Instore[1].strptr = NULL ;
675
676 rc = RexxStart( 0, NULL, "Testing", Instore, "Foo", RXCOMMAND,
677 Exits, NULL, NULL ) ;
678
679 RexxDeregisterExit( "init", NULL ) ;
680 RexxDeregisterExit( "term", NULL ) ;
681 }
682
683
684
685 LONG APIENTRY vars_exit( LONG ExNum, LONG Subfun, PEXIT PBlock )
686 {
687 SHVBLOCK shv[10] ;
688 int rc ;
689 RXSIOSAY_PARM *psiosay;
690
691 iverify( "Say exit", ExNum, RXSIO ) ;
692 iverify( "Say exit", Subfun, RXSIOSAY ) ;
693
694 psiosay = (RXSIOSAY_PARM *)PBlock;
695 sverify( "Say exit", &(psiosay->rxsio_string), "Hello" ) ;
696
697 shv[0].shvnext = &(shv[1]) ;
698 shv[0].shvname.strptr = "BAR" ;
699 shv[0].shvname.strlength = strlen( shv[0].shvname.strptr ) ;
700 shv[0].shvnamelen = shv[0].shvname.strlength ;
701 shv[0].shvvalue.strptr = "B-value-AR" ;
702 shv[0].shvvalue.strlength = strlen( shv[0].shvvalue.strptr ) ;
703 shv[0].shvvaluelen = shv[0].shvvalue.strlength ;
704 shv[0].shvcode = RXSHV_SYSET ;
705
706 /* Try to get it with lower case letters */
707 shv[1].shvnext = &(shv[2]) ;
708 shv[1].shvname.strptr = "bar " ;
709 shv[1].shvname.strlength = strlen( shv[1].shvname.strptr ) ;
710 shv[1].shvnamelen = shv[1].shvname.strlength ;
711 shv[1].shvvalue.strptr = (char *)RexxAllocateMemory( 64 ) ;
712 shv[1].shvvalue.strlength = 64 ;
713 shv[1].shvvaluelen = shv[1].shvvalue.strlength ;
714 shv[1].shvcode = RXSHV_SYFET ;
715
716 /* then we use capital letters */
717 shv[2].shvnext = &(shv[3]) ;
718 shv[2].shvname.strptr = "BAR" ;
719 shv[2].shvname.strlength = strlen( shv[2].shvname.strptr ) ;
720 shv[2].shvnamelen = shv[2].shvname.strlength ;
721 shv[2].shvvalue.strptr = (char *)RexxAllocateMemory( 64 ) ;
722 shv[2].shvvalue.strlength = 64 ;
723 shv[2].shvvaluelen = shv[2].shvvalue.strlength ;
724 shv[2].shvcode = RXSHV_SYFET ;
725
726 /* Then we set it to something else */
727 shv[3].shvnext = &(shv[4]) ;
728 shv[3].shvname.strptr = "BAR" ;
729 shv[3].shvname.strlength = strlen( shv[3].shvname.strptr ) ;
730 shv[3].shvnamelen = shv[3].shvname.strlength ;
731 shv[3].shvvalue.strptr = "new value" ;
732 shv[3].shvvalue.strlength = strlen( shv[3].shvvalue.strptr ) ;
733 shv[3].shvvaluelen = shv[3].shvvalue.strlength ;
734 shv[3].shvcode = RXSHV_SYSET ;
735
736 /* And get it */
737 shv[4].shvnext = &(shv[5]) ;
738 shv[4].shvname.strptr = "BAR" ;
739 shv[4].shvname.strlength = strlen( shv[4].shvname.strptr ) ;
740 shv[4].shvnamelen = shv[4].shvname.strlength ;
741 shv[4].shvvalue.strptr = (char *)RexxAllocateMemory( 64 ) ;
742 shv[4].shvvalue.strlength = 64 ;
743 shv[4].shvvaluelen = shv[4].shvvalue.strlength ;
744 shv[4].shvcode = RXSHV_SYFET ;
745
746 /* And drop it */
747 shv[5].shvnext = &(shv[6]) ;
748 shv[5].shvname.strptr = "BAR" ;
749 shv[5].shvname.strlength = strlen( shv[5].shvname.strptr ) ;
750 shv[5].shvnamelen = shv[5].shvname.strlength ;
751 shv[5].shvvalue.strptr = NULL ;
752 shv[5].shvvalue.strlength = 0 ;
753 shv[5].shvvaluelen = shv[5].shvvalue.strlength ;
754 shv[5].shvcode = RXSHV_SYDRO ;
755
756 /* And then we try to get it again */
757 shv[6].shvnext = &(shv[7]) ;
758 shv[6].shvname.strptr = "BAR" ;
759 shv[6].shvname.strlength = strlen( shv[6].shvname.strptr ) ;
760 shv[6].shvnamelen = shv[6].shvname.strlength ;
761 shv[6].shvvalue.strptr = (char *)RexxAllocateMemory( 64 ) ;
762 shv[6].shvvalue.strlength = 64 ;
763 shv[6].shvvaluelen = shv[6].shvvalue.strlength ;
764 shv[6].shvcode = RXSHV_SYFET ;
765
766 shv[7].shvnext = &(shv[8]) ;
767 shv[7].shvname.strptr = "FOO" ;
768 shv[7].shvname.strlength = strlen( shv[7].shvname.strptr ) ;
769 shv[7].shvnamelen = shv[7].shvname.strlength ;
770 shv[7].shvvalue.strptr = "OOPS" ;
771 shv[7].shvvalue.strlength = strlen( shv[7].shvvalue.strptr ) ;
772 shv[7].shvvaluelen = shv[7].shvvalue.strlength ;
773 shv[7].shvcode = RXSHV_SYSET ;
774
775 shv[8].shvnext = &(shv[9]) ;
776 shv[8].shvname.strptr = "ABC.FOO" ;
777 shv[8].shvname.strlength = strlen( shv[8].shvname.strptr ) ;
778 shv[8].shvnamelen = shv[8].shvname.strlength ;
779 shv[8].shvvalue.strptr = "hello, there! ... this is a long string" ;
780 shv[8].shvvalue.strlength = strlen( shv[8].shvvalue.strptr ) ;
781 shv[8].shvvaluelen = shv[8].shvvalue.strlength ;
782 shv[8].shvcode = RXSHV_SYSET ;
783
784 shv[9].shvnext = NULL ;
785 shv[9].shvname.strptr = "ABC.OOPS" ;
786 shv[9].shvname.strlength = strlen( shv[9].shvname.strptr ) ;
787 shv[9].shvnamelen = shv[9].shvname.strlength ;
788 shv[9].shvvalue.strptr = (char *)RexxAllocateMemory(16) ;
789 shv[9].shvvalue.strlength = 16 ;
790 shv[9].shvvaluelen = shv[9].shvvalue.strlength ;
791 shv[9].shvcode = RXSHV_SYFET ;
792
793
794 rc = RexxVariablePool( shv ) ;
795 iverify( "Term exit", rc, RXSHV_TRUNC | RXSHV_BADN | RXSHV_NEWV ) ;
796
797 iverify( "Term exit1 ", shv[0].shvret, RXSHV_NEWV ) ;
798 iverify( "Term exit2 ", shv[1].shvret, RXSHV_BADN ) ;
799 iverify( "Term exit3 ", shv[2].shvret, RXSHV_OK ) ;
800 iverify( "Term exit4 ", shv[3].shvret, RXSHV_OK ) ;
801 iverify( "Term exit5 ", shv[4].shvret, RXSHV_OK ) ;
802 iverify( "Term exit6 ", shv[5].shvret, RXSHV_OK ) ;
803 iverify( "Term exit7 ", shv[6].shvret, RXSHV_NEWV ) ;
804 iverify( "Term exit8 ", shv[7].shvret, RXSHV_NEWV ) ;
805 iverify( "Term exit9 ", shv[8].shvret, RXSHV_NEWV ) ;
806 iverify( "Term exit10", shv[9].shvret, RXSHV_TRUNC ) ;
807
808
809 sverify( "Term exit1 ", &(shv[2].shvvalue), "B-value-AR" ) ;
810 sverify( "Term exit2 ", &(shv[4].shvvalue), "new value" ) ;
811 sverify( "Term exit3 ", &(shv[6].shvvalue), "BAR" ) ;
812 sverify( "Term exit4 ", &(shv[9].shvvalue), "hello, there! .." ) ;
813
814 return RXEXIT_HANDLED ;
815 }
816
817 static void vars(void)
818 {
819 RXSTRING Instore[2] ;
820 RXSYSEXIT Exits[4] ;
821 int rc ;
822
823 message( "vars" ) ;
824
825 RexxRegisterExitExe( "hepp", vars_exit, NULL ) ;
826
827 Exits[0].sysexit_name = "hepp" ;
828 Exits[0].sysexit_code = RXSIO ;
829 Exits[1].sysexit_code = RXENDLST ;
830
831 Instore[0].strptr =
832 "say 'Hello'" ;
833 Instore[0].strlength = strlen( Instore[0].strptr ) ;
834 Instore[1].strptr = NULL ;
835
836 rc = RexxStart( 0, NULL, "Testing", Instore, "Foo", RXCOMMAND,
837 Exits, NULL, NULL ) ;
838
839 RexxDeregisterExit( "hepp", NULL ) ;
840 }
841
842
843
844
845 LONG APIENTRY source_exit( LONG code, LONG subcode, PEXIT ptr )
846 {
847 SHVBLOCK Req[6] ;
848
849 Req[0].shvnext = &(Req[1]) ;
850 Req[0].shvcode = RXSHV_PRIV ;
851 Req[0].shvname.strptr = "SOURCE" ;
852 Req[0].shvname.strlength = strlen( Req[0].shvname.strptr ) ;
853 Req[0].shvnamelen = Req[0].shvname.strlength ;
854 Req[0].shvvalue.strptr = NULL ;
855
856 Req[1].shvnext = &(Req[2]) ;
857 Req[1].shvcode = RXSHV_PRIV ;
858 Req[1].shvname.strptr = "VERSION" ;
859 Req[1].shvname.strlength = strlen( Req[1].shvname.strptr ) ;
860 Req[1].shvnamelen = Req[1].shvname.strlength ;
861 Req[1].shvvalue.strptr = NULL ;
862
863 Req[2].shvnext = &(Req[3]) ;
864 Req[2].shvcode = RXSHV_PRIV ;
865 Req[2].shvname.strptr = "PARM" ;
866 Req[2].shvname.strlength = strlen( Req[2].shvname.strptr ) ;
867 Req[2].shvnamelen = Req[2].shvname.strlength ;
868 Req[2].shvvalue.strptr = NULL ;
869
870 Req[3].shvnext = &(Req[4]) ;
871 Req[3].shvcode = RXSHV_PRIV ;
872 Req[3].shvname.strptr = "PARM.1" ;
873 Req[3].shvname.strlength = strlen( Req[3].shvname.strptr ) ;
874 Req[3].shvnamelen = Req[3].shvname.strlength ;
875 Req[3].shvvalue.strptr = NULL ;
876
877 Req[4].shvnext = &(Req[5]) ;
878 Req[4].shvcode = RXSHV_PRIV ;
879 Req[4].shvname.strptr = "PARM.2" ;
880 Req[4].shvname.strlength = strlen( Req[4].shvname.strptr ) ;
881 Req[4].shvnamelen = Req[4].shvname.strlength ;
882 Req[4].shvvalue.strptr = NULL ;
883
884 Req[5].shvnext = NULL ;
885 Req[5].shvcode = RXSHV_PRIV ;
886 Req[5].shvname.strptr = "QUENAME" ;
887 Req[5].shvname.strlength = strlen( Req[5].shvname.strptr ) ;
888 Req[5].shvnamelen = Req[5].shvname.strlength ;
889 Req[5].shvvalue.strptr = NULL ;
890
891 iverify( "Termin exit", code, RXTER ) ;
892 iverify( "Termin exit", subcode, RXTEREXT ) ;
893
894 RexxVariablePool( Req ) ;
895
896 iverify( "Source", Req[0].shvret, RXSHV_OK ) ;
897 iverify( "Version", Req[1].shvret, RXSHV_OK ) ;
898 if (memcmp(Req[1].shvvalue.strptr, "REXX", 4 ))
899 mycomplain( "Invalid Rexx source string\n" ) ;
900
901 iverify( "Parms", Req[2].shvret, RXSHV_OK ) ;
902 sverify( "Parms", &(Req[2].shvvalue), "1" ) ;
903
904 iverify( "Parm1a", Req[3].shvret, RXSHV_OK ) ;
905 sverify( "Parm1b", &(Req[3].shvvalue), "one two three" ) ;
906
907 iverify( "Parm2a", Req[4].shvret, RXSHV_OK ) ;
908 sverify( "Parm2b", &(Req[4].shvvalue), NULL ) ;
909
910 iverify( "QueName", Req[5].shvret, RXSHV_OK ) ;
911 sverify( "QueName", &(Req[5].shvvalue), "SESSION" ) ;
912
913 return RXEXIT_HANDLED ;
914 }
915
916
917
918 static void source( void )
919 {
920 RXSYSEXIT Exits[2] ;
921 RXSTRING Instore[2] ;
922 RXSTRING Params[2] ;
923 int rc ;
924
925 message("private") ;
926
927 RexxRegisterExitExe("hei", source_exit, NULL ) ;
928
929 Exits[0].sysexit_name = "hei" ;
930 Exits[0].sysexit_code = RXTER ;
931 Exits[1].sysexit_code = RXENDLST ;
932
933 Params[0].strptr = "one two three" ;
934 Params[0].strlength = strlen( Params[0].strptr ) ;
935
936 Instore[0].strptr = "nop" ;
937 Instore[0].strlength = strlen( Instore[0].strptr ) ;
938 Instore[1].strptr = NULL ;
939
940 rc = RexxStart( 1, Params, "Testing", Instore, "Foo", RXCOMMAND,
941 Exits, NULL, NULL ) ;
942
943 RexxDeregisterExit( "hei", NULL ) ;
944 }
945
946
947
948
949 LONG APIENTRY parms( LONG code, LONG subcode, PEXIT ptr )
950 {
951 RXSYSEXIT Exits[2] ;
952 RXSTRING Instore[2] ;
953 RXSTRING Params[5] ;
954 int rc ;
955 static int done = 0 ;
956
957 if (code == -1)
958 {
959 message("parms") ;
960
961 RexxRegisterExitExe("hei", parms, NULL ) ;
962
963 Exits[0].sysexit_name = "hei" ;
964 Exits[0].sysexit_code = RXTER ;
965 Exits[1].sysexit_code = RXENDLST ;
966
967 Params[0].strptr = "one two three" ;
968 Params[0].strlength = strlen( Params[0].strptr ) ;
969 Params[1].strptr = NULL ;
970 Params[1].strlength = 5 ;
971 Params[2].strptr = "" ;
972 Params[2].strlength = strlen( Params[2].strptr ) ;
973 Params[3].strptr = "four five" ;
974 Params[3].strlength = strlen( Params[3].strptr ) ;
975 Params[4].strptr = NULL ;
976 Params[4].strlength = 10 ;
977
978 Instore[0].strptr = "nop" ;
979 Instore[0].strlength = strlen( Instore[0].strptr ) ;
980 Instore[1].strptr = NULL ;
981
982 rc = RexxStart( 5, Params, "Testing", Instore, "Foo", RXFUNCTION,
983 Exits, NULL, NULL ) ;
984
985 if (!done)
986 printf("not done\n") ;
987
988 RexxDeregisterExit( "hei", NULL ) ;
989 return 0 ;
990 }
991 else
992 {
993 SHVBLOCK Req[7] ;
994
995 done = 1 ;
996 Req[0].shvnext = &(Req[1]) ;
997 Req[0].shvcode = RXSHV_PRIV ;
998 Req[0].shvname.strptr = "PARM" ;
999 Req[0].shvname.strlength = strlen( Req[0].shvname.strptr ) ;
1000 Req[0].shvnamelen = Req[0].shvname.strlength ;
1001 Req[0].shvvalue.strptr = NULL ;
1002
1003 Req[1].shvnext = &(Req[2]) ;
1004 Req[1].shvcode = RXSHV_PRIV ;
1005 Req[1].shvname.strptr = "PARM.1" ;
1006 Req[1].shvname.strlength = strlen( Req[1].shvname.strptr ) ;
1007 Req[1].shvnamelen = Req[1].shvname.strlength ;
1008 Req[1].shvvalue.strptr = NULL ;
1009
1010 Req[2].shvnext = &(Req[3]) ;
1011 Req[2].shvcode = RXSHV_PRIV ;
1012 Req[2].shvname.strptr = "PARM.2" ;
1013 Req[2].shvname.strlength = strlen( Req[2].shvname.strptr ) ;
1014 Req[2].shvnamelen = Req[2].shvname.strlength ;
1015 Req[2].shvvalue.strptr = NULL ;
1016
1017 Req[3].shvnext = &(Req[4]) ;
1018 Req[3].shvcode = RXSHV_PRIV ;
1019 Req[3].shvname.strptr = "PARM.3" ;
1020 Req[3].shvname.strlength = strlen( Req[3].shvname.strptr ) ;
1021 Req[3].shvnamelen = Req[3].shvname.strlength ;
1022 Req[3].shvvalue.strptr = NULL ;
1023
1024 Req[4].shvnext = &(Req[5]) ;
1025 Req[4].shvcode = RXSHV_PRIV ;
1026 Req[4].shvname.strptr = "PARM.4" ;
1027 Req[4].shvname.strlength = strlen( Req[4].shvname.strptr ) ;
1028 Req[4].shvnamelen = Req[4].shvname.strlength ;
1029 Req[4].shvvalue.strptr = NULL ;
1030
1031 Req[5].shvnext = &(Req[6]) ;
1032 Req[5].shvcode = RXSHV_PRIV ;
1033 Req[5].shvname.strptr = "PARM.5" ;
1034 Req[5].shvname.strlength = strlen( Req[5].shvname.strptr ) ;
1035 Req[5].shvnamelen = Req[5].shvname.strlength ;
1036 Req[5].shvvalue.strptr = NULL ;
1037
1038 Req[6].shvnext = NULL ;
1039 Req[6].shvcode = RXSHV_PRIV ;
1040 Req[6].shvname.strptr = "PARM.6" ;
1041 Req[6].shvname.strlength = strlen( Req[6].shvname.strptr ) ;
1042 Req[6].shvnamelen = Req[6].shvname.strlength ;
1043 Req[6].shvvalue.strptr = NULL ;
1044
1045 iverify( "Termin exit", code, RXTER ) ;
1046 iverify( "Termin exit", subcode, RXTEREXT ) ;
1047
1048 RexxVariablePool( Req ) ;
1049
1050 iverify( "Parm", Req[0].shvret, RXSHV_OK ) ;
1051 sverify( "Parm", &(Req[0].shvvalue), "5" ) ;
1052
1053 iverify( "Parm1", Req[1].shvret, RXSHV_OK ) ;
1054 sverify( "Parm1", &(Req[1].shvvalue), "one two three" ) ;
1055
1056 iverify( "Parm2", Req[2].shvret, RXSHV_OK ) ;
1057 sverify( "Parm2", &(Req[2].shvvalue), NULL ) ;
1058
1059 iverify( "Parm3", Req[3].shvret, RXSHV_OK ) ;
1060 sverify( "Parm3", &(Req[3].shvvalue), "" ) ;
1061
1062 iverify( "Parm4", Req[4].shvret, RXSHV_OK ) ;
1063 sverify( "Parm4", &(Req[4].shvvalue), "four five" ) ;
1064
1065 iverify( "Parm5", Req[5].shvret, RXSHV_OK ) ;
1066 sverify( "Parm5", &(Req[5].shvvalue), NULL ) ;
1067
1068 iverify( "Parm6", Req[6].shvret, RXSHV_OK ) ;
1069 sverify( "Parm6", &(Req[6].shvvalue), NULL ) ;
1070
1071 return RXEXIT_HANDLED ;
1072 }
1073 }
1074
1075
1076
1077
1078
1079 LONG APIENTRY allvars( LONG code, LONG subcode, PEXIT ptr )
1080 {
1081 RXSYSEXIT Exits[2] ;
1082 RXSTRING Instore[2] ;
1083 RXSTRING Params[5] ;
1084 int rc ;
1085 static int done = 0 ;
1086
1087 if (code == -1)
1088 {
1089 message("allvars") ;
1090
1091 RexxRegisterExitExe("hei", allvars, NULL ) ;
1092
1093 Exits[0].sysexit_name = "hei" ;
1094 Exits[0].sysexit_code = RXTER ;
1095 Exits[1].sysexit_code = RXENDLST ;
1096
1097 Params[0].strptr = "one two three" ;
1098 Params[0].strlength = strlen( Params[0].strptr ) ;
1099 Params[1].strptr = NULL ;
1100 Params[1].strlength = 5 ;
1101 Params[2].strptr = "" ;
1102 Params[2].strlength = strlen( Params[2].strptr ) ;
1103 Params[3].strptr = "four five" ;
1104 Params[3].strlength = strlen( Params[3].strptr ) ;
1105 Params[4].strptr = NULL ;
1106 Params[4].strlength = 10 ;
1107
1108 Instore[0].strptr = "foo='one';bar='';foo.='two';foo.bar='three';"
1109 "foo.4='four';foo.5='five';drop foo.5 foo.6" ;
1110
1111 Instore[0].strlength = strlen( Instore[0].strptr ) ;
1112 Instore[1].strptr = NULL ;
1113
1114 rc = RexxStart( 5, Params, "Testing", Instore, "Foo", RXFUNCTION,
1115 Exits, NULL, NULL ) ;
1116
1117 if (!done)
1118 printf("not done\n") ;
1119
1120 RexxDeregisterExit( "hei", NULL ) ;
1121 return 0 ;
1122 }
1123 else
1124 {
1125 SHVBLOCK Req[10] ;
1126 int i ;
1127
1128 done = 1 ;
1129 for (i=0; i<10; i++)
1130 {
1131 Req[i].shvnext = (i<10-1) ? (&(Req[i+1])) : NULL ;
1132 Req[i].shvcode = RXSHV_NEXTV ;
1133 Req[i].shvname.strptr = Req[i].shvvalue.strptr = NULL ;
1134 }
1135
1136 iverify( "Termin exit", code, RXTER ) ;
1137 iverify( "Termin exit", subcode, RXTEREXT ) ;
1138
1139 RexxVariablePool( Req ) ;
1140
1141 iverify( "Parm0", Req[0].shvret, RXSHV_OK ) ;
1142 sverify( "Parm0a", &(Req[0].shvname), "BAR" ) ;
1143 sverify( "Parm0b", &(Req[0].shvvalue), "" ) ;
1144
1145 iverify( "Parm1", Req[1].shvret, RXSHV_OK ) ;
1146 sverify( "Parm1a", &(Req[1].shvname), "FOO." ) ;
1147 sverify( "Parm1b", &(Req[1].shvvalue), "three" ) ;
1148
1149 iverify( "Parm2", Req[2].shvret, RXSHV_OK ) ;
1150 sverify( "Parm2a", &(Req[2].shvname), "FOO.4" ) ;
1151 sverify( "Parm2b", &(Req[2].shvvalue), "four" ) ;
1152
1153 iverify( "Parm3", Req[3].shvret, RXSHV_OK ) ;
1154 sverify( "Parm3a", &(Req[3].shvname), "FOO.5" ) ;
1155 sverify( "Parm3b", &(Req[3].shvvalue), "FOO.5" ) ;
1156
1157 iverify( "Parm4", Req[4].shvret, RXSHV_OK ) ;
1158 sverify( "Parm4a", &(Req[4].shvname), "FOO.6" ) ;
1159 sverify( "Parm4b", &(Req[4].shvvalue), "FOO.6" ) ;
1160
1161 iverify( "Parm5", Req[5].shvret, RXSHV_OK ) ;
1162 sverify( "Parm5a", &(Req[5].shvname), "FOO." ) ;
1163 sverify( "Parm5b", &(Req[5].shvvalue), "two" ) ;
1164
1165 iverify( "Parm6", Req[6].shvret, RXSHV_OK ) ;
1166 sverify( "Parm6a", &(Req[6].shvname), "FOO" ) ;
1167 sverify( "Parm6b", &(Req[6].shvvalue), "one" ) ;
1168
1169 iverify( "Parm", Req[7].shvret, RXSHV_LVAR ) ;
1170 iverify( "Parm", Req[8].shvret, RXSHV_OK ) ;
1171 iverify( "Parm", Req[9].shvret, RXSHV_OK ) ;
1172
1173 return RXEXIT_HANDLED ;
1174 }
1175 }
1176
1177
1178
1179
1180
1181
1182 ULONG APIENTRY extfunc( PCSZ name, ULONG params, RXSTRING *parm, PCSZ stck, RXSTRING *ptr )
1183 {
1184 RXSTRING Instore[2] ;
1185 RXSTRING Result ;
1186 int rc ;
1187 short nret ;
1188 static int done = 0 ;
1189
1190 if (name == NULL)
1191 {
1192 message("extfunc") ;
1193
1194 RexxRegisterFunctionExe("EXTFUNC", extfunc ) ;
1195
1196 Instore[0].strptr = "return extfunc('asdf','qwer',,'zxcv') + 'EXTFUNC'('asdf',,'wer','werrew')" ;
1197 Instore[0].strlength = strlen( Instore[0].strptr ) ;
1198 Instore[1].strptr = NULL ;
1199
1200 Result.strlength = 10 ;
1201 Result.strptr = (char *)RexxAllocateMemory( 10 ) ;
1202
1203 rc = RexxStart( 0, NULL, "Testing", Instore, "Foo", RXFUNCTION,
1204 NULL, &nret, &Result ) ;
1205
1206 sverify( "extfunc", &Result, "7" ) ;
1207 iverify( "extfunc", nret, 7 ) ;
1208
1209 if (!done)
1210 printf("not done\n") ;
1211
1212 RexxDeregisterFunction( "EXTFUNC" ) ;
1213 return 0 ;
1214 }
1215 else
1216 {
1217 static int once=0 ;
1218
1219 done = 1 ;
1220 if (!once)
1221 {
1222 ptr->strptr[0] = '3' ;
1223 ptr->strlength = 1 ;
1224 once = 1 ;
1225 }
1226 else
1227 {
1228 ptr->strptr[0] = '4' ;
1229 ptr->strlength = 1 ;
1230 }
1231 return 0 ;
1232 }
1233 }
1234
1235 LONG APIENTRY subcom_exit( LONG ExNum, LONG Subfun, PEXIT PBlock )
1236 {
1237 RXCMDHST_PARM *pcmdhst;
1238
1239 iverify( "Subcom Funcion", ExNum, RXCMD ) ;
1240 iverify( "Subcom Subfunc", Subfun, RXCMDHST ) ;
1241 pcmdhst = (RXCMDHST_PARM *)PBlock;
1242 pcmdhst->rxcmd_retc.strlength = 2;
1243 strcpy(pcmdhst->rxcmd_retc.strptr,"16");
1244
1245 return RXEXIT_HANDLED ;
1246 }
1247
1248 ULONG APIENTRY run_subcom(PRXSTRING Command, PUSHORT Flags, PRXSTRING Retstr)
1249 {
1250 RXSYSEXIT Exits[4] ;
1251 RXSTRING Instore[2] ;
1252 RXSTRING Result ;
1253 int rc ;
1254 short nret ;
1255
1256 if (Command == NULL)
1257 {
1258 message("subcom") ;
1259
1260 RexxRegisterExitExe( "slhepp", subcom_exit, NULL ) ;
1261
1262 Exits[0].sysexit_name = "slhepp" ;
1263 Exits[0].sysexit_code = RXCMD ;
1264 Exits[1].sysexit_code = RXENDLST ;
1265
1266 RexxRegisterSubcomExe("SUBCOM", run_subcom, NULL ) ;
1267
1268 Instore[0].strptr = "'foobar asdf qwer'" ;
1269 Instore[0].strlength = strlen( Instore[0].strptr ) ;
1270 Instore[1].strptr = NULL ;
1271
1272 Result.strlength = 20 ;
1273 Result.strptr = (char *)RexxAllocateMemory( 20 ) ;
1274
1275 rc = RexxStart( 0, NULL, "Testing", Instore, "SUBCOM", RXCOMMAND,
1276 Exits, &nret, &Result ) ;
1277
1278 /* sverify( "subcom result", &Result, "16" ) ; */
1279 /* iverify( "subcom retc", nret, 16 ) ; */
1280
1281 RexxDeregisterSubcom( "SUBCOM" , NULL) ;
1282 RexxDeregisterExit( "slhepp", NULL ) ;
1283
1284 return 0 ;
1285 }
1286 else
1287 {
1288 sprintf(Retstr->strptr,"%ld",Command->strlength) ;
1289 Retstr->strlength = strlen(Retstr->strptr);
1290 *Flags = RXSUBCOM_OK;
1291 return 0 ;
1292 }
1293
1294 }
1295
1296 static void qtest( void )
1297 {
1298 RXSTRING Instore[2] ;
1299 RXSYSEXIT Exits[3] ;
1300 int rc ;
1301 char result[100];
1302 ULONG dup;
1303
1304 message( "queue" ) ;
1305
1306 rc = RexxCreateQueue( result, sizeof(result), NULL, &dup ) ;
1307 iverify( "qtest-before", rc, RXQUEUE_OK ) ;
1308 iverify( "qtest-before", dup, 0L ) ;
1309
1310 Exits[0].sysexit_name = "query_init" ;
1311 Exits[0].sysexit_code = RXINI ;
1312 Exits[1].sysexit_name = "query_term" ;
1313 Exits[1].sysexit_code = RXTER ;
1314 Exits[2].sysexit_code = RXENDLST ;
1315 RexxRegisterExitExe( "query_init", query_init_exit, NULL ) ;
1316 RexxRegisterExitExe( "query_term", query_term_exit, NULL ) ;
1317
1318 Instore[0].strptr = "call rxqueue 'Set', 'test1';"
1319 "if queued() \\= 2 then say 'error:line 2';"
1320 "parse pull line;"
1321 "if line \\= 'line1' then say 'error:line 4';"
1322 "parse pull line;"
1323 "if line \\= 'line2' then say 'error:line 5';"
1324 "if rxqueue('Create','FRED') \\= 'FRED' then say 'error:line 6';"
1325 "if rxqueue('Set','FRED') \\= 'TEST1' then say 'error:line 7';"
1326 "push '1line';push '2line';" ;
1327 Instore[0].strlength = strlen( Instore[0].strptr ) ;
1328 Instore[1].strptr = NULL ;
1329 rc = RexxStart( 0, NULL, "Testing", Instore, "Foo", RXCOMMAND,
1330 Exits, NULL, NULL ) ;
1331
1332 RexxFreeMemory( Instore[1].strptr ) ;
1333 RexxDeregisterExit( "query_init", NULL ) ;
1334 RexxDeregisterExit( "query_term", NULL ) ;
1335
1336 rc = RexxDeleteQueue( result );
1337 iverify( "qtest-after", rc, RXQUEUE_OK ) ;
1338 }
1339
1340 static void (*(routines[]))(void) = {
1341 instore,
1342 trace,
1343 intertrc,
1344 pull,
1345 env,
1346 init_term,
1347 vars,
1348 source,
1349 NULL
1350 } ;
1351
1352
1353 static RexxExitHandler *(exits[]) = {
1354 parms,
1355 allvars,
1356 NULL
1357 } ;
1358
1359
1360 static RexxFunctionHandler *(efuncs[]) = {
1361 extfunc,
1362 NULL
1363 } ;
1364
1365 static RexxSubcomHandler *(scfuncs[]) = {
1366 run_subcom,
1367 NULL
1368 } ;
1369
1370 char char82( void )
1371 {
1372 return (char) 0x82;
1373 }
1374
1375 char char0( void )
1376 {
1377 return '\0';
1378 }
1379
1380 int main( int argc, char *argv[] )
1381 {
1382 void (**fptr)( void ) ;
1383 RexxExitHandler **eptr ;
1384 RexxFunctionHandler **gptr ;
1385 RexxSubcomHandler **sptr;
1386 RXSTRING version;
1387 ULONG versioncode;
1388
1389 /* We want to see surprisings at once: */
1390 setvbuf(stdout,NULL,_IONBF,0);
1391 setvbuf(stderr,NULL,_IONBF,0);
1392 printf( "Regina Rexx API Tester\n" );
1393 printf( "----------------------\n" );
1394
1395 version.strlength = 0;
1396 version.strptr = NULL;
1397 /* This might not work if we check another Rexx: */
1398 versioncode = ReginaVersion(&version);
1399 printf("Regina's version (via ReginaVersion API call) is %lu.%lu",
1400 versioncode >> 8,
1401 versioncode & 0xFF);
1402 if (version.strptr)
1403 {
1404 printf(" (in complete \"%s\")",version.strptr);
1405 RexxFreeMemory(version.strptr);
1406 }
1407 printf("\n");
1408
1409 if ( char82() < char0() )
1410 printf( "WARNING: Current compiler uses `signed char' as default!\n" );
1411
1412 for( fptr=routines; *fptr; fptr++ )
1413 (*fptr)() ;
1414
1415 for( eptr=exits; *eptr; eptr++ )
1416 (*eptr)( -1, -1, NULL ) ;
1417
1418 for( gptr=efuncs; *gptr; gptr++ )
1419 (*gptr)( NULL, 0, NULL, NULL, NULL ) ;
1420
1421 for( sptr=scfuncs; *sptr; sptr++ )
1422 (*sptr)( NULL, 0, NULL ) ;
1423 #if !defined(NO_EXTERNAL_QUEUES)
1424 qtest();
1425 #endif
1426 init_term_show();
1427 ReginaCleanup();
1428 printf( "\n" ) ;
1429 return 0 ;
1430 }