/*
 * Source generated with ARexxBox 1.13 (Dec  4 1993)
 * which is Copyright (c) 1992,1993 Michael Balzer
 */

#include <exec/types.h>
#include <exec/memory.h>
#include <dos/dos.h>
#include <rexx/storage.h>
#include <rexx/rxslib.h>

#ifdef __GNUC__
/* GCC needs all struct defs */
#include <dos/exall.h>
#include <graphics/graphint.h>
#include <intuition/classes.h>
#include <devices/keymap.h>
#include <exec/semaphores.h>
#endif

#include <clib/alib_protos.h>
#include <clib/exec_protos.h>
#include <clib/dos_protos.h>
#include <clib/rexxsyslib_protos.h>

#ifndef __NO_PRAGMAS

#ifdef AZTEC_C
#include <pragmas/exec_lib.h>
#include <pragmas/dos_lib.h>
#include <pragmas/rexxsyslib_lib.h>
#endif

#ifdef LATTICE
#include <pragmas/exec_pragmas.h>
#include <pragmas/dos_pragmas.h>
#include <pragmas/rexxsyslib_pragmas.h>
#endif

#endif /* __NO_PRAGMAS */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>

#ifdef LATTICE
#define inline __inline
#endif

#ifdef __GNUC__
#undef toupper
static inline char toupper( char c )
{
	return( islower(c) ? c - 'a' + 'A' : c );
}
#endif

#ifdef AZTEC_C
#define inline
#endif

#include "md_rexx.h"


extern struct ExecBase *SysBase;
extern struct DosLibrary *DOSBase;
extern struct RxsLib *RexxSysBase;


/* $ARB: I 754885886 */


/* $ARB: B 1 GETMODE */

#include "microdot.h"

void rx_getmode( struct RexxHost *host, struct rxd_getmode **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_getmode *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
			break;
			
		case RXIF_ACTION:
			/* Insert your CODE here */
			rd->rc2 = rexxmode;
			rd->res.mode = &rexxmode;
			rd->rc = 0;
			break;
		
		case RXIF_FREE:
			/* FREE your local data here */
			FreeVec( rd );
			break;
	}
	return;
}
/* $ARB: E 1 GETMODE */

/* $ARB: B 2 GETCURRENTMAILHEADER */
void rx_getcurrentmailheader( struct RexxHost *host, struct rxd_getcurrentmailheader **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_getcurrentmailheader *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
			if( rd = *rxd )
			{
				/* set your DEFAULTS here */
			}
			break;
			
		case RXIF_ACTION:
			if( ( rexxmode != 1 ) && ( rexxmode != 2 ) )
			{
				rd->rc = -10;
				rd->rc2 = (ULONG) "Illegal mode";
				break;
			}
			else
			{
				struct header *hl;
				struct hlist *hlist;
				struct msghandle *msg;
				int count;

				msg = opencurrentmail();

				if( msg )
				{
					hlist = msg_loadheader( msg );
					hl = hl_findheader( hlist, rd->arg.header );
					count = rd->arg.index ? *rd->arg.index : 0;
					while( hl && count-- )
						hl = hl_findnextheader( hl );
					if( hl )
					{
						rd->rc = 0;
						rd->rc2 = NULL;
						rd->res.data = StrDup( host, hl->data );
					}
					else
					{
						rd->rc = 10;
						rd->rc2 = ERROR_NO_MORE_ENTRIES;
					}
					hl_freeheader( hlist );
					msg_close( msg );

					break;
				}
			}
			rd->rc = -10;
			rd->rc = (ULONG) "no current mail";
			break;
		
		case RXIF_FREE:
			/* FREE your local data here */
			FreeVec( rd );
			break;
	}
	return;
}
/* $ARB: E 2 GETCURRENTMAILHEADER */

/* $ARB: B 8 HELP */
void rx_help( struct RexxHost *host, struct rxd_help **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_help *rd = *rxd;
	struct rxs_command *rxc;

	/*
	 * Dieser HELP-Befehl unterstützt (noch) nicht das PROMPT-Keyword
	 * da das nur im Rahmen eines GUIs Sinn hat
	 */

	switch( action )
	{
		case RXIF_INIT:
			*rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
			break;
			
		case RXIF_ACTION:
			/* Insert your code HERE */
			
			if( rd->arg.prompt )
			{
				rd->rc = 0;
				rd->rc2 = 0;
				showguide( "arexx_commands" );
				return;
			}
			
			if( rd->arg.command )
			{
				rxc = FindRXCommand( rd->arg.command );
				if( !rxc )
				{
					rd->rc = -10;
					rd->rc2 = (long) "Unknown Command";
					return;
				}

				if( ( rd->res.commanddesc = AllocVec( strlen( rxc->command )
					+ (rxc->args    ? strlen(rxc->args)    : 0)
					+ (rxc->results ? strlen(rxc->results) : 0) + 42,
					MEMF_ANY) ) )
				{
					sprintf( rd->res.commanddesc,
						"%s%lc%s%s%s%s%s",
						rxc->command, 
						(rxc->results || rxc->args) ? ' ' : '\0',
						rxc->results ? "VAR/K,STEM/K" : "",
						(rxc->results && rxc->args) ? "," : "",
						rxc->args ? rxc->args : "",
						rxc->results ? " => " : "",
						rxc->results ? rxc->results : "" );
				}
				else
				{
					rd->rc = 10;
					rd->rc2 = ERROR_NO_FREE_STORE;
					return;
				}
			}
			else
			{
				char **s;
				
				if( !(s = AllocVec(sizeof(char *) * ( command_cnt + 1 ), MEMF_CLEAR)) )
				{
					rd->rc = 10;
					rd->rc2 = ERROR_NO_FREE_STORE;
					return;
				}
				rd->res.commandlist = s;
				
				rxc = rxs_commandlist;
				while( rxc->command )
				{
					*s = rxc->command;
					s++;
					rxc++;
				}
			}
			
			break;
		
		case RXIF_FREE:
			/* FREE your local data HERE */
			
			if( rd->res.commanddesc )
				FreeVec( rd->res.commanddesc );
			if( rd->res.commandlist )
				FreeVec( rd->res.commandlist );
			
			FreeVec( rd );
			break;
	}
	return;
}
/* $ARB: E 8 HELP */

/* $ARB: B 9 RX */
void rx_rx( struct RexxHost *host, struct rxd_rx **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct {
		struct rxd_rx rd;
		long rc;
	} *rd = (void *) *rxd;
	
	BPTR fh = NULL;
	struct RexxMsg *sentrm;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = ARBAlloc( host, sizeof *rd );
			break;
			
		case RXIF_ACTION:
			/* Insert your code HERE */
			
			/* Kommando leer? */
			if( !rd->rd.arg.command )
				return;
			
			/* Mit Ein-/Ausgabe-Fenster? */
			if( rd->rd.arg.console )
			{
				fh = OpenCon( "CON:////RX Window/AUTO" );
				if( !fh )
				{
					rd->rd.rc = -20;
					rd->rd.rc2 = (long) "RX can't open Window";
					return;
				}
			}
			
			/* Kommando abschicken */
			if( !(sentrm = SendRexxCommand(host, rd->rd.arg.command, fh)) )
			{
				rd->rd.rc = -20;
				rd->rd.rc2 = (long) "RX can't send ARexx command";
				return;
			}
			
			/* auf den Reply warten */
			if( !rd->rd.arg.async )
			{
				struct RexxMsg *rm;
				int waiting = TRUE;
				
				do
				{
					WaitPort( host->port );
					
					while( rm = (struct RexxMsg *) GetMsg(host->port) )
					{
						/* Reply? */
						if( rm->rm_Node.mn_Node.ln_Type == NT_REPLYMSG )
						{
							/* 'unsere' Msg? */
							if( rm == sentrm )
							{
								rd->rc = rm->rm_Result1;
								rd->rd.res.rc = &rd->rc;
								
								if( !rm->rm_Result1 && rm->rm_Result2 )
								{
									/* Res2 ist String */
									rd->rd.res.result =
										StrDup( host, (char *) rm->rm_Result2 );
								}
								
								waiting = FALSE;
							}
							
							FreeRexxCommand( rm );
							--host->replies;
						}
						
						/* sonst Kommando -> Fehler */
						else if( ARG0(rm) )
						{
							ReplyRexxCommand( rm, -20, (long)
								"CommandShell Port", NULL );
						}
					}
				}
				while( waiting );
			}
			
			break;
		
		case RXIF_FREE:
			/* FREE your local data HERE */
			if( rd->rd.res.result ) ARBFree( host, rd->rd.res.result );
			ARBFree( host, rd );
			break;
	}
	return;
}
/* $ARB: E 9 RX */

/* $ARB: B 10 EXTRACTCURRENTMAIL */
void rx_extractcurrentmail( struct RexxHost *host, struct rxd_extractcurrentmail **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_extractcurrentmail *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
			if( rd = *rxd )
			{
				/* set your DEFAULTS here */
			}
			break;
			
		case RXIF_ACTION:
			if( ( rexxmode != 1 ) && ( rexxmode != 2 ) )
			{
				rd->rc = -10;
				rd->rc2 = (ULONG) "Illegal mode";
				break;
			}
			else
			{
				struct msghandle *msg;
				int what = MC_DATA;

				if( rd->arg.header )
					what |= MC_HEADER;
				if( rd->arg.comment )
					what |= MC_COMMENT;

				msg = opencurrentmail();

				if( msg )
				{
					msg_copy( msg, rd->arg.file, what );
					rd->rc = 0;
					rd->rc2 = 0;

					msg_close( msg );

					break;
				}
			}
			/* Insert your CODE here */
			rd->rc = -10;
			rd->rc = (ULONG) "no current mail";
			break;
		
		case RXIF_FREE:
			/* FREE your local data here */
			FreeVec( rd );
			break;
	}
	return;
}
/* $ARB: E 10 EXTRACTCURRENTMAIL */

/* $ARB: B 11 MDVERSION */
void rx_mdversion( struct RexxHost *host, struct rxd_mdversion **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_mdversion *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
			break;
			
		case RXIF_ACTION:
			/* Insert your CODE here */
			rd->rc = 0;
			rd->rc2 = MDUPDVER;
			rd->res.version = MDVER;
			break;
		
		case RXIF_FREE:
			/* FREE your local data here */
			FreeVec( rd );
			break;
	}
	return;
}
/* $ARB: E 11 MDVERSION */

/* $ARB: B 12 GETMDPUBSCREENNAME */
void rx_getmdpubscreenname( struct RexxHost *host, struct rxd_getmdpubscreenname **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_getmdpubscreenname *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
			break;
			
		case RXIF_ACTION:
			/* Insert your CODE here */
			rd->rc = 0;
			rd->rc2 = !wbwindow;
			rd->res.pubscreenname = ( pubscreenname ) ? pubscreenname : "Workbench";
			break;
		
		case RXIF_FREE:
			/* FREE your local data here */
			FreeVec( rd );
			break;
	}
	return;
}
/* $ARB: E 12 GETMDPUBSCREENNAME */

/* $ARB: B 13 SENDSHORTMAIL */
void rx_sendshortmail( struct RexxHost *host, struct rxd_sendshortmail **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_sendshortmail *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = ARBAlloc( host, sizeof *rd );
			if( rd = *rxd )
			{
				rd->arg.subject = "";
				/* set your DEFAULTS here */
			}
			break;
			
		case RXIF_ACTION:
			/* Insert your CODE here */
			sendshortmail( rd->arg.to, rd->arg.subject, rd->arg.text, ( rd->arg.referenceid ) ? rd->arg.referenceid : NULL, NULL, NULL, 1 );
			rd->rc = 0;
			break;
		
		case RXIF_FREE:
			/* FREE your local data here */
			ARBFree( host, rd );
			break;
	}
	return;
}
/* $ARB: E 13 SENDSHORTMAIL */

/* $ARB: B 14 SENDMAIL */
extern int sendwinauto;
void rx_sendmail( struct RexxHost *host, struct rxd_sendmail **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_sendmail *rd = *rxd;
	static ULONG rc;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = ARBAlloc( host, sizeof *rd );
			if( rd = *rxd )
			{
				/* set your DEFAULTS here */
			}
			break;
			
		case RXIF_ACTION:
			sendwinauto = !rd->arg.wait;
			if( !rd->arg.bin )
				copyfile( rd->arg.bodyfile, TMPMSGNAME );
			if( rd->arg.commentfile )
				copyfile( rd->arg.commentfile, TMPCOMMENTNAME );

			rc = dosendwin( "Per ARexx verschickte Nachricht",
				rd->arg.subject,
				rd->arg.shortcomment,
				rd->arg.referenceid,
				rd->arg.to,
				rd->arg.bin ? 1 : 0,
				NULL, NULL,
				rd->arg.followup_to,
				NULL,
				NULL,
				( rd->arg.bin ) ? rd->arg.bodyfile : NULL,
				( rd->arg.bin ) ? FilePart( rd->arg.bodyfile ): NULL,
				NULL
			);

			rd->res.rc = &rc;

			/* Insert your CODE here */
			rd->rc = 0;

			displayscroller();
			break;
		
		case RXIF_FREE:
			/* FREE your local data here */
			ARBFree( host, rd );
			break;
	}
	return;
}
/* $ARB: E 14 SENDMAIL */

/* $ARB: B 15 GETCURRENTBOARD */
/* ATT: Interface changed! Check arg/res/name consistency! */
extern struct mbrett *cmb;
void rx_getcurrentboard( struct RexxHost *host, struct rxd_getcurrentboard **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_getcurrentboard *rd = *rxd;
	struct mbrett *brett=(struct mbrett*)GetEntry( &brettlist, getscrollercurrent() );
	static ULONG holddays, nocrunch, subpm, select;

	if( rexxmode )
		brett = cmb;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = ARBAlloc( host, sizeof *rd );
			break;
			
		case RXIF_ACTION:
			select = brett->n.ln_Type ? 1 : 0;
			nocrunch = ( brett->b.flags & BFLAG_NOCRUNCH ) ? 1 : 0;
			subpm = ( brett->b.flags & BFLAG_EXTEND_PM ) ? 1 : 0;

			/* Insert your CODE here */
			holddays = brett->b.days;
			rd->res.name = StrDup( host, brett->b.name );
			rd->res.mails = &brett->b.mails;
			rd->res.newmails = &brett->b.newmails;
			rd->res.unreadmails = &brett->b.unreadmails;
			rd->res.holddays = &holddays;
			rd->res.nodelete = &nocrunch;
			rd->res.subpm = &subpm;
			rd->res.selected = &select;
			rd->res.updatetime = &brett->b.lastwrite;
			rd->rc = 0;
			break;
		
		case RXIF_FREE:
			/* FREE your local data here */
			ARBFree( host, rd );
			break;
	}
	return;
}
/* $ARB: E 15 GETCURRENTBOARD */

/* $ARB: B 16 GETPREFS */
void rx_getprefs( struct RexxHost *host, struct rxd_getprefs **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_getprefs *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = ARBAlloc( host, sizeof *rd );
			break;
			
		case RXIF_ACTION:
			/* Insert your CODE here */
			rd->res.username = StrDup( host, prefs.username );
			rd->res.userrealname = StrDup( host, prefs.userrealname );
			rd->res.pointname = StrDup( host, prefs.pointname );
			rd->res.servername = StrDup( host, prefs.boxname );
			rd->res.serverdomain = StrDup( host, prefs.boxdomain );
			rd->rc = 0;
			break;
		
		case RXIF_FREE:
			/* FREE your local data here */
			ARBFree( host, rd );
			break;
	}
	return;
}
/* $ARB: E 16 GETPREFS */

/* $ARB: B 17 GETCURRENTMAIL */
/* ATT: Interface changed! Check arg/res/name consistency! */
/* ATT: Interface changed! Check arg/res/name consistency! */
void rx_getcurrentmail( struct RexxHost *host, struct rxd_getcurrentmail **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_getcurrentmail *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = ARBAlloc( host, sizeof *rd );
			break;
			
		case RXIF_ACTION:
			/* Insert your CODE here */
			if( ( rexxmode != 1 ) && ( rexxmode != 2 ) )
			{
				rd->rc = -10;
				rd->rc2 = (ULONG) "Illegal mode";
				break;
			}
			else
			{
				struct vmail *v = getcurrentmail();

				if( v )
				{
					static ULONG readf, newf, holdf, delf, binf, showf, rx1f, rx2f, self;

					readf = ( v->m->m.flags & MMF_READ ) ? 1 : 0;
					newf = ( v->m->m.flags & MMF_UNSEEN ) ? 1 : 0;
					holdf = ( v->m->m.flags & MMF_ARCHIVE ) ? 1 : 0;
					delf  = ( v->m->m.flags & MMF_DEL ) ? 1 : 0;
					binf  = ( v->m->m.flags & MMF_BIN ) ? 1 : 0;
					showf = ( v->m->m.flags & MMF_SHOW ) ? 1 : 0;
					rx1f = ( v->m->m.flags & MMF_RX1 ) ? 1 : 0;
					rx2f = ( v->m->m.flags & MMF_RX2 ) ? 1 : 0;
					self  = ( v->sel ) ? 1 : 0;

					rd->res.from = StrDup( host, v->m->m.absender );
					rd->res.fromreal = StrDup( host, v->m->m.absenderreal );
					rd->res.subject = StrDup( host, v->m->m.betreff );
					rd->res.midhash = &v->m->m.midcrc;
					rd->res.refhash = &v->m->m.bezcrc;
					rd->res.length = &v->m->m.maillen;
					rd->res.new = &newf;
					rd->res.read = &readf;
					rd->res.hold = &holdf;
					rd->res.del = &delf;
					rd->res.bin = &binf;
					rd->res.show = &showf;
					rd->res.selected = &self;
					rd->res.rx1 = &rx1f;
					rd->res.rx2 = &rx2f;
					rd->res.sendtime = &v->m->m.time;
					rd->res.incometime = &v->m->m.incomtime;

					rd->rc = 0;
					break;
				}
			}
			rd->rc = -10;
			rd->rc = (ULONG) "no current mail";
			break;
		
		case RXIF_FREE:
			/* FREE your local data here */
			ARBFree( host, rd );
			break;
	}
	return;
}
/* $ARB: E 17 GETCURRENTMAIL */

/* $ARB: B 18 EDITOR */
void rx_editor( struct RexxHost *host, struct rxd_editor **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_editor *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = ARBAlloc( host, sizeof *rd );
			if( rd = *rxd )
			{
				/* set your DEFAULTS here */
			}
			break;
			
		case RXIF_ACTION:
			/* Insert your CODE here */
			rd->res.rc = 0;
			calleditor( rd->arg.file );
			rd->rc = 0;
			break;
		
		case RXIF_FREE:
			/* FREE your local data here */
			ARBFree( host, rd );
			break;
	}
	return;
}
/* $ARB: E 18 EDITOR */

/* $ARB: B 19 GETPOS */
void rx_getpos( struct RexxHost *host, struct rxd_getpos **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_getpos *rd = *rxd;
	static ULONG pos;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = ARBAlloc( host, sizeof *rd );
			break;
			
		case RXIF_ACTION:
			pos = getscrollercurrent();
			rd->res.rc = &pos;
			/* Insert your CODE here */
			rd->rc = 0;
			break;
		
		case RXIF_FREE:
			/* FREE your local data here */
			ARBFree( host, rd );
			break;
	}
	return;
}
/* $ARB: E 19 GETPOS */

/* $ARB: B 20 SETPOS */
/* ATT: Interface changed! Check arg/res/name consistency! */
void rx_setpos( struct RexxHost *host, struct rxd_setpos **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_setpos *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = ARBAlloc( host, sizeof *rd );
			if( rd = *rxd )
			{
				/* set your DEFAULTS here */
			}
			break;
			
		case RXIF_ACTION:
			rd->rc = 0;
			if( rd->arg.up )
				setscrollercurrent( getscrollercurrent() - 1 );
			else if( rd->arg.down )
				setscrollercurrent( getscrollercurrent() + 1 );
			else if( rd->arg.gotopos )	
				setscrollercurrent( *rd->arg.gotopos );
			else
				rd->rc = 1;

			showcurrentitem();

			/* Insert your CODE here */
			rd->rc = 0;
			break;
		
		case RXIF_FREE:
			/* FREE your local data here */
			ARBFree( host, rd );
			break;
	}
	return;
}
/* $ARB: E 20 SETPOS */

/* $ARB: B 21 CHOOSE */
/* ATT: Interface changed! Check arg/res/name consistency! */
/* ATT: Interface changed! Check arg/res/name consistency! */
int scrollerenter;
void rx_choose( struct RexxHost *host, struct rxd_choose **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_choose *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = ARBAlloc( host, sizeof *rd );
			if( rd = *rxd )
			{
				/* set your DEFAULTS here */
			}
			break;
			
		case RXIF_ACTION:
			if( rexxmode == 2 )
			{
				rd->rc = -10;
				rd->rc2 = (ULONG) "Illegal mode";
				break;
			}
			else
			{
				static int isselected;

				isselected = ( getscrollerselect() ) ? TRUE : FALSE;

				if( rd->arg.off )
					scrollerselect( 0, 0 );
				else if( rd->arg.toggle )
					scrollerselect( 0, !isselected );
				else if( rd->arg.allon )
					scrollerselect( TRUE, TRUE );
				else if( rd->arg.alloff )
					scrollerselect( TRUE, FALSE );
				else if( rd->arg.enter )
					scrollerenter = TRUE;
				else if( !rd->arg.test )
					scrollerselect( 0, TRUE );

				if( !rexxmode )
					calcbcount();
				else
					calcmcount();

				rd->res.rc = &isselected;
				/* Insert your CODE here */
				rd->rc = 0;
			}
			break;
		
		case RXIF_FREE:
			/* FREE your local data here */
			ARBFree( host, rd );
			break;
	}
	return;
}
/* $ARB: E 21 CHOOSE */

/* $ARB: B 22 CRUNCH */
void rx_crunch( struct RexxHost *host, struct rxd_crunch **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_crunch *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = ARBAlloc( host, sizeof *rd );
			break;
			
		case RXIF_ACTION:
			if( rexxmode )
			{
				rd->rc = -10;
				rd->rc2 = (ULONG) "Illegal mode";
				break;
			}
			/* Insert your CODE here */
			docrunch( ( struct mbrett*)-1 );
			rd->rc = 0;
			break;
		
		case RXIF_FREE:
			/* FREE your local data here */
			ARBFree( host, rd );
			break;
	}
	return;
}
/* $ARB: E 22 CRUNCH */

/* $ARB: B 23 REORG */
void rx_reorg( struct RexxHost *host, struct rxd_reorg **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_reorg *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = ARBAlloc( host, sizeof *rd );
			if( rd = *rxd )
			{
				/* set your DEFAULTS here */
			}
			break;
			
		case RXIF_ACTION:
			if( rexxmode )
			{
				rd->rc = -10;
				rd->rc2 = (ULONG) "Illegal mode";
				break;
			}
			/* Insert your CODE here */
			doreorg2( rd->arg.merge );
			rd->rc = 0;
			break;
		
		case RXIF_FREE:
			/* FREE your local data here */
			ARBFree( host, rd );
			break;
	}
	return;
}
/* $ARB: E 23 REORG */

/* $ARB: B 24 NETCALL */
void rx_netcall( struct RexxHost *host, struct rxd_netcall **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_netcall *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = ARBAlloc( host, sizeof *rd );
			break;
			
		case RXIF_ACTION:
			if( rexxmode )
			{
				rd->rc = -10;
				rd->rc2 = (ULONG) "Illegal mode";
				break;
			}
			/* Insert your CODE here */
			if( !dospool() )
			{
				if( !donetcall( 0 ) )
				{
					delspool();
					dosortin();
					sortbrettlist();
					calcbcount();
					displayscroller();
					rd->res.rc = 0;
					break;
				}
			}
			rd->rc = 0;
			break;
		
		case RXIF_FREE:
			/* FREE your local data here */
			ARBFree( host, rd );
			break;
	}
	return;
}
/* $ARB: E 24 NETCALL */

/* $ARB: B 25 GOTOBOARD */
/* ATT: Interface changed! Check arg/res/name consistency! */
/* ATT: Interface changed! Check arg/res/name consistency! */
void rx_gotoboard( struct RexxHost *host, struct rxd_gotoboard **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_gotoboard *rd = *rxd;
	struct mbrett *mb;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = ARBAlloc( host, sizeof *rd );
			if( rd = *rxd )
			{
				/* set your DEFAULTS here */
			}
			break;
			
		case RXIF_ACTION:
			if( rexxmode )
			{
				rd->rc = -10;
				rd->rc2 = (ULONG) "Illegal mode";
				break;
			}

			mb = findbrett( rd->arg.name, 0 );
			if( mb )
			{
				setscrollercurrent( GetEntryNum( &brettlist, mb ) );
				showcurrentitem();
				rd->rc = 0;
			}
			else
				rd->rc = 5;

			break;
		
		case RXIF_FREE:
			/* FREE your local data here */
			ARBFree( host, rd );
			break;
	}
	return;
}
/* $ARB: E 25 GOTOBOARD */

/* $ARB: B 26 SETCURRENTMAILFLAGS */
extern struct mindex *mix;
static void setmailflag( long *state, ULONG flag, struct vmail *v )
{
	if( state )
	{
		if( *state )
			v->m->m.flags |= flag;
		else
			v->m->m.flags &= ~flag;
		mix->changed = 1;
	}
}

void rx_setcurrentmailflags( struct RexxHost *host, struct rxd_setcurrentmailflags **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_setcurrentmailflags *rd = *rxd;
	struct vmail *v;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = ARBAlloc( host, sizeof *rd );
			if( rd = *rxd )
			{
				/* set your DEFAULTS here */
			}
			break;
			
		case RXIF_ACTION:
			if( ( rexxmode != 1 ) && ( rexxmode != 2 ) )
			{
				rd->rc = -10;
				rd->rc2 = (ULONG) "Illegal mode";
				break;
			}

			v = getcurrentmail();
			if( v )
			{
				setmailflag( rd->arg.new, MMF_UNSEEN, v );
				setmailflag( rd->arg.read, MMF_READ, v );
				setmailflag( rd->arg.hold, MMF_ARCHIVE, v );
				setmailflag( rd->arg.del, MMF_DEL, v );
				setmailflag( rd->arg.show, MMF_SHOW, v );
				setmailflag( rd->arg.rx1, MMF_RX1, v );
				setmailflag( rd->arg.rx2, MMF_RX2, v );
				if( rd->arg.selected )
				{
					if( *rd->arg.selected )
						v->sel = 0xff;
					else
						v->sel = 0;
				}
				displaycurrentline();
				calcmcount();
			}
			/* Insert your CODE here */
			rd->rc = 0;
			break;
		
		case RXIF_FREE:
			/* FREE your local data here */
			ARBFree( host, rd );
			break;
	}
	return;
}
/* $ARB: E 26 SETCURRENTMAILFLAGS */

/* $ARB: B 28 REQUEST */
void rx_request( struct RexxHost *host, struct rxd_request **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_request *rd = *rxd;
	static ULONG rc;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = ARBAlloc( host, sizeof *rd );
			if( rd = *rxd )
			{
				/* set your DEFAULTS here */
			}
			break;
			
		case RXIF_ACTION:
			rc = askreq( rd->arg.text, rd->arg.gadgets );
			rd->res.rc = &rc;
			/* Insert your CODE here */
			rd->rc = 0;
			break;
		
		case RXIF_FREE:
			/* FREE your local data here */
			ARBFree( host, rd );
			break;
	}
	return;
}
/* $ARB: E 28 REQUEST */

/* $ARB: B 30 QUIT */
extern int rexxquitflag;
void rx_quit( struct RexxHost *host, struct rxd_quit **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_quit *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = ARBAlloc( host, sizeof *rd );
			break;
			
		case RXIF_ACTION:
			rexxquitflag = TRUE;
			/* Insert your CODE here */
			rd->rc = 0;
			break;
		
		case RXIF_FREE:
			/* FREE your local data here */
			ARBFree( host, rd );
			break;
	}
	return;
}
/* $ARB: E 30 QUIT */

/* $ARB: B 31 NOREQUEST */
extern int noreq;
void rx_norequest( struct RexxHost *host, struct rxd_norequest **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_norequest *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = ARBAlloc( host, sizeof *rd );
			if( rd = *rxd )
			{
				/* set your DEFAULTS here */
			}
			break;
			
		case RXIF_ACTION:
			/* Insert your CODE here */
			if( rd->arg.off )
				noreq = FALSE;
			else
				noreq = TRUE;
			rd->rc = 0;
			break;
		
		case RXIF_FREE:
			/* FREE your local data here */
			ARBFree( host, rd );
			break;
	}
	return;
}
/* $ARB: E 31 NOREQUEST */


#ifndef RX_ALIAS_C
char *ExpandRXCommand( struct RexxHost *host, char *command )
{
	/* Insert your ALIAS-HANDLER here */
	return( NULL );
}
#endif