?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
make sure "S" is generated.
[AROS-Contrib.git] / bgui / arexxclass.c
blobaa25e19502779a0d086755192dde9ea872304381
1 /*
2 * @(#) $Header$
3 *
4 * BGUI library
5 * arexxclass.c
6 *
7 * (C) Copyright 1998 Manuel Lemos.
8 * (C) Copyright 1996-1997 Ian J. Einman.
9 * (C) Copyright 1993-1996 Jaba Development.
10 * (C) Copyright 1993-1996 Jan van den Baard.
11 * All Rights Reserved.
12 *
13 * $Log$
14 * Revision 42.3 2004/06/16 20:16:48 verhaegs
15 * Use METHODPROTO, METHOD_END and REGFUNCPROTOn where needed.
16 *
17 * Revision 42.2 2000/08/08 20:57:26 chodorowski
18 * Minor fixes to build on Amiga.
19 *
20 * Revision 42.1 2000/05/15 19:27:00 stegerg
21 * another hundreds of REG() macro replacements in func headers/protos.
22 *
23 * Revision 42.0 2000/05/09 22:08:13 mlemos
24 * Bumped to revision 42.0 before handing BGUI to AROS team
25 *
26 * Revision 41.11 2000/05/09 20:21:32 mlemos
27 * Bumped to revision 41.11
28 *
29 * Revision 41.1 2000/05/09 19:53:44 mlemos
30 * Merged with the branch Manuel_Lemos_fixes.
31 *
32 * Revision 1.1.2.1 1998/10/12 01:32:38 mlemos
33 * Initial revision adapted from Ian sources.
34 *
35 *
36 *
37 */
38
39 /*
40 ** Include necessary headers.
41 **/
42 #include "include/classdefs.h"
43
44 /*
45 ** Object instance data. Every object
46 ** created from this class has this
47 ** data.
48 **/
49 typedef struct {
50 struct MsgPort *ad_Port; /* Host message port. */
51 UBYTE *ad_HostName; /* Host name. */
52 UBYTE *ad_FileExt; /* File extention. */
53 ULONG ad_PendCnt; /* Messages still un-replied. */
54 REXXCOMMAND *ad_Commands; /* Host command list. */
55 struct RDArgs *ad_DOSParser; /* ReadArgs() parser. */
56 } AD;
57
58 /*
59 ** Class data.
60 **/
61 typedef struct {
62 struct Library *RexxSysLibraryBase;
63 } CD;
64
65 #define RexxSysBase ((CD *)cl->cl_UserData)->RexxSysLibraryBase
66
67 /*
68 ** Duplicate a string.
69 **/
70 STATIC UBYTE *DupStr( AD *ad, UBYTE *str )
71 {
72 UBYTE *dup = BGUI_AllocPoolMem( strlen( str ) + 1 );
73
74 /*
75 ** Allocation OK?
76 **/
77 if ( dup )
78 /*
79 ** Copy the string.
80 **/
81 strcpy( dup, str );
82
83 return( dup );
84 }
85
86 /*
87 ** Reply a rexx command.
88 **/
89 STATIC VOID ReplyRexxCommand(Class *cl, struct RexxMsg *rxm, LONG prim, LONG sec, UBYTE *res )
90 {
91 UBYTE buf[ 16 ];
92
93 /*
94 ** Result wanted?
95 **/
96 if ( rxm->rm_Action & RXFF_RESULT ) {
97 /*
98 ** Primary result?
99 **/
100 if ( ! prim ) {
101 /*
102 ** We setup the secondary result to
103 ** the result string when one was passed.
104 **/
105 sec = res ? ( LONG )CreateArgstring( res, strlen( res )) : 0L;
106 } else {
107 /*
108 ** Primary result bigger than 0?
109 **/
110 if ( prim > 0 ) {
111 /*
112 ** Setup the result field
113 ** to point to a string containing
114 ** the secondary result number.
115 **/
116 sprintf( buf, "%ld", sec );
117 res = buf;
118 } else {
119 /*
120 ** Negate primary result and
121 ** setup the result field to
122 ** the secondary result.
123 **/
124 prim = -prim;
125 res = ( UBYTE * )sec;
126 }
127
128 /*
129 ** Setup ARexx it's "RC2" variable to
130 ** the result.
131 **/
132 SetRexxVar( rxm, "RC2", res, strlen( res ));
133
134 /*
135 ** Clear secondary result.
136 **/
137 sec = 0;
138 }
139 } else if ( prim < 0 )
140 /*
141 ** Negate primary result.
142 **/
143 prim = -prim;
144
145 /*
146 ** Setup result fields.
147 **/
148 rxm->rm_Result1 = prim;
149 rxm->rm_Result2 = sec;
150
151 /*
152 ** Reply the RexxMsg.
153 **/
154 ReplyMsg(( struct Message * )rxm );
155 }
156
157 /*
158 ** Free a RexxMsg command.
159 **/
160 STATIC VOID FreeRexxCommand(Class *cl, struct RexxMsg *rxm )
161 {
162 /*
163 ** Delete the result Argstring.
164 **/
165 if ( ! rxm->rm_Result1 && rxm->rm_Result2 )
166 DeleteArgstring(( UBYTE * )rxm->rm_Result2 );
167
168 /*
169 ** Close input handle.
170 **/
171 if ( rxm->rm_Stdin && rxm->rm_Stdin != Input()) {
172 /*
173 ** If the output handle is the
174 ** same as the input handle we
175 ** can safely clear it.
176 **/
177 if ( rxm->rm_Stdout == rxm->rm_Stdin )
178 rxm->rm_Stdout = NULL;
179 Close( rxm->rm_Stdin );
180 rxm->rm_Stdin = NULL;
181 }
182
183 /*
184 ** Close output handle if it is not
185 ** the same as Stdin.
186 **/
187 if ( rxm->rm_Stdout && rxm->rm_Stdout != Output()) {
188 Close( rxm->rm_Stdout );
189 rxm->rm_Stdout = NULL;
190 }
191
192 /*
193 ** Delete the command Argstring.
194 **/
195 DeleteArgstring(( UBYTE * )ARG0( rxm ));
196 /*
197 ** Delete the message itself.
198 **/
199 DeleteRexxMsg( rxm );
200 }
201
202 /*
203 ** Create a RexxMsg command.
204 **/
205 STATIC struct RexxMsg *CreateRexxCommand(Class *cl, AD *ad, UBYTE *comname, BPTR handle )
206 {
207 struct RexxMsg *rxm;
208
209 /*
210 ** Create the RexxMsg.
211 **/
212 if ( rxm = CreateRexxMsg( ad->ad_Port, ad->ad_FileExt, ad->ad_HostName )) {
213 /*
214 ** Create the Argstring.
215 **/
216 if ( rxm->rm_Args[ 0 ] = CreateArgstring( comname, strlen( comname ))) {
217 /*
218 ** Setup action flags.
219 **/
220 rxm->rm_Action = RXCOMM | RXFF_RESULT;
221 /*
222 ** Setup file handles.
223 **/
224 rxm->rm_Stdin = rxm->rm_Stdout = handle;
225 return( rxm );
226 }
227 /*
228 ** Argstring creation failed.
229 **/
230 DeleteRexxMsg( rxm );
231 }
232 return( NULL );
233 }
234
235 /*
236 ** Send a RexxMsg command to the
237 ** ARexx server.
238 **/
239 STATIC struct RexxMsg *CommandToRexx( AD *ad, struct RexxMsg *rxm )
240 {
241 struct MsgPort *rxp;
242
243 /*
244 ** Try to find the "REXX"
245 ** message port.
246 **/
247 Forbid();
248
249 if ( ! ( rxp = FindPort( RXSDIR ))) {
250 /*
251 ** Oops. ARexx server
252 ** not active.
253 **/
254 Permit();
255 return( NULL );
256 }
257
258 /*
259 ** Send off the message.
260 **/
261 PutMsg( rxp, &rxm->rm_Node );
262
263 Permit();
264
265 /*
266 ** Increase pending counter.
267 **/
268 ad->ad_PendCnt++;
269
270 return( rxm );
271 }
272
273 /*
274 ** Send a command to the ARexx server.
275 **/
276 STATIC struct RexxMsg *SendRexxCommand(Class *cl, AD *ad, UBYTE *comname, BPTR handle)
277 {
278 struct RexxMsg *rxm;
279
280 /*
281 ** Create a RexxMsg command and
282 ** send it off to the ARexx server.
283 **/
284 if (rxm = CreateRexxCommand(cl, ad, comname, handle))
285 return CommandToRexx(ad, rxm);
286
287 return NULL;
288 }
289
290 STATIC REXXCOMMAND *FindRXCommand( AD *ad, UBYTE *comname, UWORD len )
291 {
292 REXXCOMMAND *rc = ad->ad_Commands;
293
294 while ( rc->rc_Func ) {
295 if ( ! strnicmp( comname, rc->rc_Name, len ) && isspace( comname[ strlen( rc->rc_Name ) ] ))
296 return( rc );
297 rc++;
298 }
299
300 return( NULL );
301 }
302
303 /*
304 ** Execute a command.
305 **/
306 STATIC VOID DoRXCommand(Class *cl, AD *ad, struct RexxMsg *rxm )
307 {
308 struct RexxMsg *rm;
309 REXXCOMMAND *rco;
310 REXXARGS *ra;
311 UBYTE *comname, *args, *tmp, *result = NULL;
312 LONG rc = 20, rc2 = 0;
313 UWORD numargs = 0, len = 0;
314
315 /*
316 ** Allocate memory for the command
317 ** name and it's argument string.
318 **/
319 if ( ! ( comname = ( UBYTE * )BGUI_AllocPoolMem( strlen(( UBYTE * )ARG0( rxm )) + 2 ))) {
320 rc2 = ERROR_NO_FREE_STORE;
321 return;
322 }
323
324 /*
325 ** Copy command name and argument string.
326 **/
327 strcpy( comname, ( UBYTE * )ARG0( rxm ));
328
329 /*
330 ** ReadArgs() requires the argument
331 ** string to end with a newline.
332 **/
333 strcat( comname, "\n" );
334
335 /*
336 ** Find the length of the command
337 ** the start of the arguments.
338 **/
339 args = comname;
340 while ( isspace( *args )) args++;
341 tmp = args;
342 while ( ! isspace( *args )) { len++; args++; }
343
344 /*
345 ** Find the command.
346 **/
347 if ( rco = FindRXCommand( ad, tmp, len )) {
348 /*
349 ** Allocate REXXARGS structure.
350 **/
351 if ( ra = ( REXXARGS * )BGUI_AllocPoolMem( sizeof( REXXARGS ))) {
352 /*
353 ** Count number of expected args.
354 **/
355 if ( rco->rc_ArgTemplate ) {
356 tmp = rco->rc_ArgTemplate;
357 while ( *tmp != '\n' ) {
358 if ( *tmp++ == ',' ) numargs++;
359 }
360 numargs++;
361 /*
362 ** Allocate arg array.
363 **/
364 if ( ra->ra_ArgList = ( ULONG * )BGUI_AllocPoolMem( numargs * sizeof( ULONG ))) {
365 /*
366 ** Setup RDArgs.
367 **/
368 ad->ad_DOSParser->RDA_Source.CS_Buffer = args;
369 ad->ad_DOSParser->RDA_Source.CS_Length = strlen( args );
370 ad->ad_DOSParser->RDA_Source.CS_CurChr = 0;
371 ad->ad_DOSParser->RDA_DAList = NULL;
372 ad->ad_DOSParser->RDA_Buffer = NULL;
373 /*
374 ** Parse args.
375 **/
376 if ( ReadArgs( rco->rc_ArgTemplate, (LONG *)ra->ra_ArgList, ad->ad_DOSParser )) {
377 /*
378 ** Call the REXX routine.
379 **/
380 ( rco->rc_Func )( ra, rxm );
381
382 rc = ra->ra_RC;
383 rc2 = ra->ra_RC2;
384 result = ra->ra_Result;
385
386 FreeArgs( ad->ad_DOSParser );
387 } else {
388 rc = 10;
389 rc2 = IoErr();
390 }
391 BGUI_FreePoolMem( ra->ra_ArgList );
392 } else
393 rc2 = ERROR_NO_FREE_STORE;
394 } else {
395 /*
396 ** No args.
397 **/
398 ( rco->rc_Func )( ra, rxm );
399
400 rc = ra->ra_RC;
401 rc2 = ra->ra_RC2;
402 result = ra->ra_Result;
403 }
404 BGUI_FreePoolMem( ra );
405 } else
406 rc2 = ERROR_NO_FREE_STORE;
407 } else {
408 /*
409 ** Not found in our list?
410 ** Maybe it's a script.
411 **/
412 if ( rm = CreateRexxCommand(cl, ad, ( UBYTE * )ARG0( rxm ), NULL )) {
413 /*
414 ** Save original message.
415 **/
416 rm->rm_Args[ 15 ] = ( STRPTR )rxm;
417 /*
418 ** Let the REXX server see what
419 ** it can do with this.
420 **/
421 if ( ! CommandToRexx( ad, rm ))
422 rc2 = ERROR_NOT_IMPLEMENTED;
423 } else
424 rc2 = ERROR_NO_FREE_STORE;
425
426 goto byeBye;
427 }
428
429 ReplyRexxCommand(cl, rxm, rc, rc2, result );
430
431 byeBye:
432
433 BGUI_FreePoolMem( comname );
434 }
435
436 /// OM_NEW
437 METHOD(ARexxClassNew, struct opSet *,ops)
438 {
439 struct TagItem *attr = ops->ops_AttrList;
440 struct MsgPort *mp;
441 AD *ad;
442 ULONG rc, *ecode, err, ext = 1;
443 UBYTE unique_name[80], *tmp;
444
445 /*
446 * Let the superclass set us up...
447 */
448 if (rc = DoSuperMethodA(cl, obj, (Msg)ops))
449 {
450 /*
451 * Get the instance data.
452 */
453 ad = INST_DATA(cl, rc);
454
455 #ifdef POOLS
456 /*
457 * Create a memory pool.
458 */
459 if (ad->ad_MemPool = LibCreatePool(MEMF_PUBLIC | MEMF_CLEAR, 4096, 4096))
460 {
461 #endif
462 /*
463 * Create port if a
464 * host name is supplied.
465 */
466 if (ad->ad_HostName = (UBYTE *)GetTagData(AC_HostName, NULL, attr))
467 {
468 /*
469 * Name valid?
470 */
471 if (*ad->ad_HostName)
472 {
473 /*
474 * Make the name unique.
475 */
476 Forbid();
477 do {
478 sprintf(unique_name, "%s.%ld", ad->ad_HostName, ext++);
479 } while ((mp = FindPort(unique_name)) && ext <= 99);
480 Permit();
481
482 /*
483 * Name unique?
484 */
485 if (!mp)
486 {
487 /*
488 * Copy the name.
489 */
490 if (ad->ad_HostName = DupStr(ad, unique_name))
491 {
492 /*
493 * Uppercase it.
494 */
495 tmp = ad->ad_HostName;
496 do {
497 *tmp = toupper(*tmp);
498 } while (*tmp++);
499
500 /*
501 * Create the port.
502 */
503 if (ad->ad_Port = CreateMsgPort())
504 {
505 /*
506 * Initialize and add the port.
507 */
508 ad->ad_Port->mp_Node.ln_Name = ad->ad_HostName;
509 ad->ad_Port->mp_Node.ln_Pri = 0;
510 AddPort(ad->ad_Port);
511 } else err = RXERR_OUT_OF_MEMORY;
512 } else err = RXERR_OUT_OF_MEMORY;
513 } else err = RXERR_PORT_ALREADY_EXISTS;
514 } else err = RXERR_NO_PORT_NAME;
515 } else err = RXERR_NO_PORT_NAME;
516
517 /*
518 * Do we have a port now?
519 */
520 if (ad->ad_Port)
521 {
522 /*
523 * Find the commandlist.
524 */
525 if (ad->ad_Commands = (REXXCOMMAND *)GetTagData(AC_CommandList, NULL, attr))
526 {
527 /*
528 * Setup the AmigaDOS parser.
529 */
530 if (ad->ad_DOSParser = (struct RDArgs *)AllocDosObject(DOS_RDARGS, NULL))
531 {
532 ad->ad_DOSParser->RDA_Flags = RDAF_NOPROMPT;
533 /*
534 * Obtain file extention.
535 */
536 ad->ad_FileExt = (UBYTE *)GetTagData(AC_FileExtention, (ULONG)"rexx", attr);
537
538 return rc;
539
540 } else err = RXERR_OUT_OF_MEMORY;
541 } else err = RXERR_NO_COMMAND_LIST;
542 }
543 #ifdef POOLS
544 } else err = RXERR_OUT_OF_MEMORY;
545 #endif
546 /*
547 * See if we got error storage.
548 */
549 ecode = (ULONG *)GetTagData(AC_ErrorCode, NULL, attr);
550 if (ecode) *ecode = err;
551
552 /*
553 * Bliep error...bliep....
554 */
555 CoerceMethod(cl, (Object *)rc, OM_DISPOSE);
556 }
557 return 0;
558 }
559 METHOD_END
560 ///
561 /// OM_DISPOSE
562 METHOD(ARexxClassDispose, Msg, msg)
563 {
564 AD *ad = ( AD * )INST_DATA( cl, obj );
565 struct RexxMsg *rxm;
566
567 /*
568 * Do we have a port?
569 */
570 if (ad->ad_Port)
571 {
572 /*
573 * Remove the port from the public list
574 */
575 RemPort(ad->ad_Port);
576 /*
577 * Wait for and handle all messages still pending.
578 */
579 while (ad->ad_PendCnt)
580 {
581 /*
582 * Wait for a message.
583 */
584 WaitPort(ad->ad_Port);
585 /*
586 * Get messages.
587 */
588 while (rxm = (struct RexxMsg *)GetMsg(ad->ad_Port))
589 {
590 /*
591 * Replied message?
592 */
593 if (rxm->rm_Node.mn_Node.ln_Type == NT_REPLYMSG)
594 {
595 /*
596 * Free the message and decrease the
597 * pending counter.
598 */
599 FreeRexxCommand(cl, rxm);
600 ad->ad_PendCnt--;
601 }
602 else
603 {
604 /*
605 * Tell'm we're getting out of here.
606 */
607 ReplyRexxCommand(cl, rxm, -20, (LONG)"Host object closing down", NULL);
608 };
609 };
610 };
611 /*
612 * In case there are no messages pending we still
613 * need to reply all that is waiting at the port.
614 */
615 while (rxm = (struct RexxMsg *)GetMsg(ad->ad_Port))
616 ReplyRexxCommand(cl, rxm, -20, (LONG)"Host object closing down", NULL);
617
618 /*
619 * Delete the port.
620 */
621 DeleteMsgPort(ad->ad_Port);
622 }
623
624 /*
625 * Delete the AmigaDOS parser.
626 */
627 if (ad->ad_DOSParser)
628 FreeDosObject(DOS_RDARGS, ad->ad_DOSParser);
629
630 /*
631 * Delete the port name.
632 */
633 if (ad->ad_HostName)
634 BGUI_FreePoolMem(ad->ad_HostName);
635
636 #ifdef POOLS
637 /*
638 * Free the pool.
639 */
640 LibDeletePool(ad->ad_MemPool);
641 #endif
642
643 /*
644 * Let the superclass do the rest.
645 */
646 return DoSuperMethodA(cl, obj, msg);
647 }
648 METHOD_END
649 ///
650 /// OM_GET
651 METHOD(ARexxClassGet, struct opGet *, opg)
652 {
653 AD *ad = INST_DATA(cl, obj);
654 ULONG rc = 1;
655
656 /*
657 ** What do they want?
658 **/
659 switch (opg->opg_AttrID)
660 {
661 case AREXX_HostName:
662 *(opg->opg_Storage) = (ULONG)ad->ad_HostName;
663 break;
664
665 case AREXX_SignalMask:
666 *(opg->opg_Storage) = (1 << ad->ad_Port->mp_SigBit);
667 break;
668
669 default:
670 rc = DoSuperMethodA(cl, obj, (Msg)opg);
671 break;
672 }
673 return rc;
674 }
675 METHOD_END
676 ///
677 /// AREXXM_EXECUTE
678 METHOD(ARexxClassExecute, struct acmExecute *, acme)
679 {
680 AD *ad = INST_DATA( cl, obj );
681 REXXCOMMAND *rco;
682 REXXARGS *ra;
683 struct RexxMsg *rxm;
684 UBYTE *args, *tmp, *result = NULL, *com;
685 UWORD numargs = 0, len = 0;
686 ULONG r = 20, r2;
687
688 /*
689 ** Allocate a private copy of the command string.
690 **/
691 if ( com = ( UBYTE * )BGUI_AllocPoolMem( strlen( acme->acme_CommandString ) + 2 )) {
692 /*
693 ** Make a copy terminated with a newline.
694 **/
695 strcpy( com, acme->acme_CommandString );
696 strcat( com, "\n" );
697 /*
698 ** Find the length of the command
699 ** and the start of the arguments.
700 **/
701 args = com;
702 while ( isspace( *args )) args++;
703 tmp = args;
704 while ( ! isspace( *args )) { len++; args++; }
705 /*
706 ** Look up the command.
707 **/
708 if ( rco = FindRXCommand( ad, tmp, len )) {
709 /*
710 ** Allocate a REXXARGS structure.
711 **/
712 if ( ra = ( REXXARGS * )BGUI_AllocPoolMem( sizeof( REXXARGS ))) {
713 /*
714 ** Args expected?
715 **/
716 if ( rco->rc_ArgTemplate ) {
717 /*
718 ** Count the expected number of arguments.
719 **/
720 tmp = rco->rc_ArgTemplate;
721 while ( *tmp != '\n' ) {
722 if ( *tmp++ != ',' ) numargs++;
723 }
724 numargs++;
725 /*
726 ** Allocate space to parse the args.
727 **/
728 if ( ra->ra_ArgList = ( ULONG * )BGUI_AllocPoolMem( numargs * sizeof( ULONG ))) {
729 /*
730 ** Setup the parser.
731 **/
732 ad->ad_DOSParser->RDA_Source.CS_Buffer = args;
733 ad->ad_DOSParser->RDA_Source.CS_Length = strlen( args );
734 ad->ad_DOSParser->RDA_Source.CS_CurChr = 0;
735 ad->ad_DOSParser->RDA_DAList = NULL;
736 ad->ad_DOSParser->RDA_Buffer = NULL;
737 /*
738 ** Parse the args.
739 **/
740 if ( ReadArgs( rco->rc_ArgTemplate, (LONG *)ra->ra_ArgList, ad->ad_DOSParser )) {
741 /*
742 ** Run command.
743 **/
744 ( rco->rc_Func )( ra, NULL );
745 /*
746 ** Store results.
747 **/
748 r = ra->ra_RC;
749 r2 = ra->ra_RC2;
750 result = ra->ra_Result;
751 FreeArgs( ad->ad_DOSParser );
752 } else {
753 r = 10;
754 r2 = IoErr();
755 }
756 /*
757 ** Deallocate arg list.
758 **/
759 BGUI_FreePoolMem( ra->ra_ArgList );
760 } else
761 r2 = ERROR_NO_FREE_STORE;
762 } else {
763 /*
764 ** Run command.
765 **/
766 ( rco->rc_Func )( ra, NULL );
767 /*
768 ** Store results.
769 **/
770 r = ra->ra_RC;
771 r2 = ra->ra_RC2;
772 result = ra->ra_Result;
773 }
774 /*
775 ** Deallocate the REXXARGS structure.
776 **/
777 BGUI_FreePoolMem( ra );
778 } else
779 r2 = ERROR_NO_FREE_STORE;
780 /*
781 ** When not passed to the rexx server
782 ** we must close the given IO handle
783 ** ourselves.
784 **/
785 if ( acme->acme_IO ) Close( acme->acme_IO );
786 } else {
787 /*
788 ** We do not send the new-line to
789 ** the ARexx server.
790 **/
791 com[ strlen( com ) - 1 ] = '\0';
792 /*
793 ** Unknown commands are shipped
794 ** off to the REXX server.
795 **/
796 if ( rxm = CreateRexxCommand(cl, ad, com, acme->acme_IO )) {
797 if ( ! CommandToRexx( ad, rxm ))
798 r2 = ERROR_NOT_IMPLEMENTED;
799 else
800 r = r2 = 0L;
801 } else
802 r2 = ERROR_NO_FREE_STORE;
803 }
804 /*
805 ** Deallocate the command copy.
806 **/
807 BGUI_FreePoolMem( com );
808 } else
809 r2 = ERROR_NO_FREE_STORE;
810
811 /*
812 ** Put the results into their
813 ** storage spaces.
814 **/
815 if ( acme->acme_RC ) *( acme->acme_RC ) = r;
816 if ( acme->acme_RC2 ) *( acme->acme_RC2 ) = r2;
817 if ( acme->acme_Result ) *( acme->acme_Result ) = result;
818
819 return( 1L );
820 }
821 METHOD_END
822 ///
823 /// AREXXM_HANDLE_EVENT
824 METHOD(ARexxClassHandleEvent, Msg, msg)
825 {
826 struct RexxMsg *rxm, *org;
827 AD *ad = INST_DATA(cl, obj);
828 ULONG rc = 1;
829
830 /*
831 * Get the messages from the port.
832 */
833 while (rxm = (struct RexxMsg *)GetMsg(ad->ad_Port))
834 {
835 /*
836 * A Rexx command?
837 */
838 if ((rxm->rm_Action & RXCODEMASK) != RXCOMM)
839 ReplyMsg((struct Message *)rxm);
840 else if (rxm->rm_Node.mn_Node.ln_Type == NT_REPLYMSG)
841 {
842 /*
843 * Reply'd message. See if it was started
844 * as a script.
845 */
846 if (org = (struct RexxMsg *)rxm->rm_Args[15])
847 {
848 if (rxm->rm_Result1)
849 ReplyRexxCommand(cl, org, 20, ERROR_NOT_IMPLEMENTED, NULL);
850 else
851 ReplyRexxCommand(cl, org, 0, 0, (UBYTE *)rxm->rm_Result2);
852 };
853 /*
854 * Free the message and decrease the pending counter.
855 */
856 FreeRexxCommand(cl, rxm);
857 ad->ad_PendCnt--;
858 }
859 else if (ARG0(rxm))
860 /*
861 * Execute message.
862 */
863 DoRXCommand(cl, ad, rxm);
864 else
865 ReplyMsg((struct Message *)rxm);
866 }
867 return rc;
868 }
869 METHOD_END
870 ///
871
872 /*
873 * Class function table.
874 */
875 STATIC DPFUNC ClassFunc[] = {
876 OM_NEW, (FUNCPTR)ARexxClassNew,
877 OM_DISPOSE, (FUNCPTR)ARexxClassDispose,
878 OM_GET, (FUNCPTR)ARexxClassGet,
879 AREXXM_HANDLE_EVENT, (FUNCPTR)ARexxClassHandleEvent,
880 AREXXM_EXECUTE, (FUNCPTR)ARexxClassExecute,
881 DF_END
882 };
883
884 METHOD(ARexxClassMethodNew, Msg, msg)
885 {
886 return((ULONG)((((CD *)cl->cl_UserData)->RexxSysLibraryBase=OpenLibrary("rexxsyslib.library",36L))!=NULL));
887 }
888 METHOD_END
889
890 METHOD(ARexxClassMethodDispose, Msg, msg)
891 {
892 CD *class_data=(CD *)cl->cl_UserData;
893
894 if(class_data->RexxSysLibraryBase)
895 {
896 CloseLibrary(class_data->RexxSysLibraryBase);
897 class_data->RexxSysLibraryBase=NULL;
898 }
899 return 1;
900 }
901 METHOD_END
902
903 /*
904 * Class methods function table.
905 */
906 STATIC DPFUNC ClassMethods[] = {
907 OM_NEW, (FUNCPTR)ARexxClassMethodNew,
908 OM_DISPOSE, (FUNCPTR)ARexxClassMethodDispose,
909 DF_END
910 };
911
912 /*
913 * Initialize the class.
914 */
915 makeproto Class *InitArexxClass(void)
916 {
917 return(BGUI_MakeClass(CLASS_DFTable, ClassFunc,
918 CLASS_ObjectSize, sizeof(AD),
919 CLASS_ClassSize, sizeof(CD),
920 CLASS_ClassDFTable, ClassMethods,
921 TAG_DONE));
922 }
Mirror of AROS' Contrib svn.