home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Frozen Fish 2: PC
/
frozenfish_august_1995.bin
/
bbs
/
d07xx
/
d0745.lha
/
ARexxBox
/
test
/
rx_test.c
< prev
next >
Wrap
C/C++ Source or Header
|
1992-10-12
|
17KB
|
927 lines
/*
* Source generated with ARexxBox 1.00 (Jun 19 1992)
* which is Copyright (c) 1992 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>
#ifndef _toupper
#define _toupper(x) ((x) & 0x5f)
#endif
#include <dos/rdargs.h>
#define NO_GLOBALS
#include "rx_test.h"
struct rxs_stemnode
{
struct rxs_stemnode *succ;
char *name;
char *value;
};
extern struct Library *SysBase, *DOSBase, *RexxSysBase;
char RexxPortBaseName[80] = "arbtest";
struct rxs_command rxs_commandlist[] =
{
{ "HELP", "COMMAND,PROMPT/S", "COMMANDDESC,COMMANDLIST/M", RESINDEX(rxd_help), rx_help, 1 },
{ "INOUT", "ARG1/N", "RES1", RESINDEX(rxd_inout), rx_inout, 1 },
{ "MULTI_IN_NUM", "LISTE/N/M", NULL, 0, rx_multi_in_num, 1 },
{ "MULTI_IN_STR", "LISTE/M", NULL, 0, rx_multi_in_str, 1 },
{ "MULTI_OUT_NUM", NULL, "LISTE/N/M", RESINDEX(rxd_multi_out_num), rx_multi_out_num, 1 },
{ "MULTI_OUT_STR", NULL, "LISTE/M", RESINDEX(rxd_multi_out_str), rx_multi_out_str, 1 },
{ "OPEN", "FILE/K,PROMPT/S", NULL, 0, rx_open, 1 },
{ NULL, NULL, NULL, NULL, NULL }
};
void ReplyRexxCommand(
struct RexxMsg *rexxmessage,
long primary,
long secondary,
char *result )
{
if( rexxmessage->rm_Action & RXFF_RESULT )
{
if( primary == 0 )
{
secondary = result
? (long) CreateArgstring( result, strlen(result) )
: (long) NULL;
}
else
{
char buf[16];
if( primary > 0 )
{
sprintf( buf, "%ld", secondary );
result = buf;
}
else
{
primary = -primary;
result = (char *) secondary;
}
SetRexxVar( (struct Message *) rexxmessage,
"RC2", result, strlen(result) );
secondary = 0;
}
}
else if( primary < 0 )
primary = -primary;
rexxmessage->rm_Result1 = primary;
rexxmessage->rm_Result2 = secondary;
ReplyMsg( (struct Message *) rexxmessage );
}
void FreeRexxCommand( struct RexxMsg *rexxmessage )
{
if( !rexxmessage->rm_Result1 && rexxmessage->rm_Result2 )
DeleteArgstring( (char *) rexxmessage->rm_Result2 );
if( rexxmessage->rm_Stdin )
Close( rexxmessage->rm_Stdin );
if( rexxmessage->rm_Stdout &&
rexxmessage->rm_Stdout != rexxmessage->rm_Stdin )
Close( rexxmessage->rm_Stdout );
DeleteArgstring( (char *) ARG0(rexxmessage) );
DeleteRexxMsg( rexxmessage );
}
struct RexxMsg *SendRexxCommand( struct RexxHost *host, char *buff, BPTR fh )
{
struct MsgPort *rexxport;
struct RexxMsg *rexx_command_message;
Forbid();
if( (rexxport = FindPort(RXSDIR)) == NULL )
{
Permit();
return( NULL );
}
if( (rexx_command_message = CreateRexxMsg( host->port,
REXX_EXTENSION, host->port->mp_Node.ln_Name)) == NULL )
{
Permit();
return( NULL );
}
if( (rexx_command_message->rm_Args[0] =
CreateArgstring(buff,strlen(buff))) == NULL )
{
DeleteRexxMsg(rexx_command_message);
Permit();
return( NULL );
}
rexx_command_message->rm_Action = RXCOMM | RXFF_RESULT;
rexx_command_message->rm_Stdin = fh;
rexx_command_message->rm_Stdout = fh;
PutMsg( rexxport, &rexx_command_message->rm_Node );
Permit();
++host->replies;
return( rexx_command_message );
}
void CloseDownARexxHost( struct RexxHost *host )
{
struct RexxMsg *rexxmsg;
while( host->replies > 0 )
{
WaitPort( host->port );
while( rexxmsg = (struct RexxMsg *)GetMsg(host->port) )
{
if( rexxmsg->rm_Node.mn_Node.ln_Type == NT_REPLYMSG )
{
FreeRexxCommand( rexxmsg );
--host->replies;
}
else
ReplyRexxCommand( rexxmsg, -20, (long) "Host closing down", NULL );
}
}
if( host->rdargs ) FreeDosObject( DOS_RDARGS, host->rdargs );
if( host->port ) DeletePort( host->port );
free( host );
}
struct RexxHost *SetupARexxHost( char *basename )
{
struct RexxHost *host;
int ext = 0;
if( !(host = calloc(sizeof *host, 1)) )
return NULL;
if( !basename )
basename = RexxPortBaseName;
strcpy( host->portname, basename );
if( !host->portname[0] )
{
free( host );
return NULL;
}
while( FindPort(host->portname) )
sprintf( host->portname, "%s.%d", basename, ++ext );
if( !(host->port = CreatePort(host->portname, 0)) )
{
free( host );
return NULL;
}
if( !(host->rdargs = AllocDosObject(DOS_RDARGS, NULL)) )
{
DeletePort( host->port );
free( host );
return NULL;
}
host->rdargs->RDA_Flags = RDAF_NOPROMPT;
return( host );
}
struct rxs_command *FindRXCommand( char *com )
{
struct rxs_command *rxc = rxs_commandlist;
int n = strlen( com );
while( rxc->command )
{
if( strnicmp(com, rxc->command, n) == 0 )
break;
rxc++;
}
if( rxc->command )
return( rxc );
else
return( NULL );
}
static struct rxs_command *ParseRXCommand( char **arg )
{
char com[256], *s, *t;
s = *arg;
t = com;
while( *s && *s != ' ' && *s != '\n' )
*t++ = *s++;
*t = '\0';
while( *s == ' ' ) ++s;
*arg = s;
return( FindRXCommand( com ) );
}
static char *CreateVAR( struct rxs_stemnode *stem )
{
char *var;
struct rxs_stemnode *s;
long size = 0;
if( !stem || stem == (struct rxs_stemnode *) -1L )
return( (char *) stem );
for( s = stem; s; s = s->succ )
size += strlen( s->value ) + 1;
var = malloc( size + 1 );
*var = '\0';
for( s = stem; s; s = s->succ )
{
strcat( var, s->value );
if( s->succ )
strcat( var, " " );
}
return( var );
}
static struct rxs_stemnode *new_stemnode( struct rxs_stemnode **first, struct rxs_stemnode **old )
{
struct rxs_stemnode *new;
if( !(new = calloc(sizeof(struct rxs_stemnode), 1)) )
{
return( NULL );
}
else
{
if( *old )
{
(*old)->succ = new;
(*old) = new;
}
else
{
*first = *old = new;
}
}
return( new );
}
static void free_stemlist( struct rxs_stemnode *first )
{
struct rxs_stemnode *next;
for( ; first; first = next )
{
next = first->succ;
free( first->name );
free( first->value );
free( first );
}
}
static struct rxs_stemnode *CreateSTEM( struct rxs_command *rxc, LONG *resarray, char *stembase )
{
struct rxs_stemnode *first = NULL, *old = NULL, *new;
char resb[512], *rs, *rb;
char longbuff[16];
if( stembase )
strcpy( resb, stembase );
else
*resb = '\0';
rb = resb + strlen(resb);
rs = rxc->results;
while( *rs )
{
char *t = rb;
BOOL optn = FALSE, optm = FALSE;
while( *rs && *rs != ',' )
{
if( *rs == '/' )
{
++rs;
if( *rs == 'N' ) optn = TRUE;
else if( *rs == 'M' ) optm = TRUE;
}
else
*t++ = *rs;
++rs;
}
if( *rs == ',' ) ++rs;
*t = '\0';
/*
* Resultat(e) erzeugen
*/
if( !*resarray )
{
++resarray;
continue;
}
if( optm )
{
long *r, index = 0;
LONG **subarray = (LONG **) *resarray++;
struct rxs_stemnode *countnd;
/* Anzahl der Elemente */
if( !(new = new_stemnode(&first, &old)) )
{
free_stemlist( first );
return( (struct rxs_stemnode *) -1L );
}
countnd = new;
/* Die Elemente selbst */
while( r = *subarray++ )
{
if( !(new = new_stemnode(&first, &old)) )
{
free_stemlist( first );
return( (struct rxs_stemnode *) -1L );
}
sprintf( t, ".%ld", index++ );
new->name = strdup( resb );
if( optn )
{
sprintf( longbuff, "%ld", *r );
new->value = strdup( longbuff );
}
else
{
new->value = strdup( (char *) r );
}
}
/* Die Count-Node */
strcpy( t, ".COUNT" );
countnd->name = strdup( resb );
sprintf( longbuff, "%ld", index );
countnd->value = strdup( longbuff );
}
else
{
/* Neue Node anlegen */
if( !(new = new_stemnode(&first, &old)) )
{
free_stemlist( first );
return( (struct rxs_stemnode *) -1L );
}
new->name = strdup( resb );
if( optn )
{
sprintf( longbuff, "%ld", *((long *) *resarray) );
new->value = strdup( longbuff );
++resarray;
}
else
{
new->value = strdup( (char *) (*resarray++) );
}
}
}
return( first );
}
static void DoRXCommand( struct RexxHost *host, struct RexxMsg *rexxmsg )
{
struct rxs_command *rxc;
char *argb = NULL, *arg;
LONG *array = NULL;
LONG *argarray;
LONG *resarray;
char *cargstr = NULL;
long rc=20, rc2=0;
char *result = NULL;
if( !(argb = malloc(strlen(ARG0(rexxmsg)) + 2)) )
{
rc2 = ERROR_NO_FREE_STORE;
goto drc_cleanup;
}
/* welches Kommando? */
strcpy( argb, ARG0(rexxmsg) );
strcat( argb, "\n" );
arg = argb;
if( !( rxc = ParseRXCommand( &arg ) ) )
{
if( arg = ExpandRXCommand( host, ARG0(rexxmsg) ) )
{
free( argb );
if( !(argb = malloc( strlen(arg) + 2 )) )
{
rc2 = ERROR_NO_FREE_STORE;
goto drc_cleanup;
}
strcpy( argb, arg );
strcat( argb, "\n" );
free( arg );
arg = argb;
rxc = ParseRXCommand( &arg );
}
}
if( !rxc )
{
rc2 = ERROR_NOT_IMPLEMENTED;
goto drc_cleanup;
}
if( !(rxc->flags & ARB_CF_ENABLED) )
{
rc = -10;
rc2 = (long) "Command disabled";
goto drc_cleanup;
}
/* Speicher fⁿr Argumente etc. holen */
(rxc->function)( host, (void **) &array, RXIF_INIT );
cargstr = malloc( rxc->args ? 15+strlen(rxc->args) : 15 );
if( !array || !cargstr )
{
rc2 = ERROR_NO_FREE_STORE;
goto drc_cleanup;
}
argarray = array + 2;
resarray = array + rxc->resindex;
/* Argumente parsen */
if( rxc->results )
strcpy( cargstr, "VAR/K,STEM/K" );
else
*cargstr = '\0';
if( rxc->args )
{
if( *cargstr )
strcat( cargstr, "," );
strcat( cargstr, rxc->args );
}
if( *cargstr )
{
host->rdargs->RDA_Source.CS_Buffer = arg;
host->rdargs->RDA_Source.CS_Length = strlen(arg);
host->rdargs->RDA_Source.CS_CurChr = 0;
host->rdargs->RDA_DAList = NULL;
host->rdargs->RDA_Buffer = NULL;
if( !ReadArgs(cargstr, argarray, host->rdargs) )
{
rc = 10;
rc2 = IoErr();
goto drc_cleanup;
}
}
/* Funktion aufrufen */
(rxc->function)( host, (void **) &array, RXIF_ACTION );
rc = array[0];
rc2 = array[1];
/* Resultat(e) auswerten */
if( rxc->results && rc==0 &&
(rexxmsg->rm_Action & RXFF_RESULT) )
{
struct rxs_stemnode *stem, *s;
stem = CreateSTEM( rxc, resarray, (char *)argarray[1] );
result = CreateVAR( stem );
if( result == (char *) -1 )
{
result = NULL;
rc = 20;
rc2 = ERROR_NO_FREE_STORE;
}
else if( result )
{
if( argarray[0] )
{
/* VAR */
if( SetRexxVar( (struct Message *) rexxmsg, (char *)argarray[0], result, strlen(result) ) )
{
rc = -10;
rc2 = (long) "Unable to set Rexx variable";
}
free( result );
result = NULL;
}
if( argarray[1] )
{
/* STEM */
for( s = stem; s; s = s->succ )
rc |= SetRexxVar( (struct Message *) rexxmsg, s->name, s->value, strlen(s->value) );
if( rc )
{
rc = -10;
rc2 = (long) "Unable to set Rexx variable";
}
if( result ) free( result );
result = NULL;
}
}
if( stem > (struct rxs_stemnode *) NULL )
free_stemlist( stem );
}
drc_cleanup:
/* Nur RESULT, wenn weder VAR noch STEM */
ReplyRexxCommand( rexxmsg, rc, rc2, result );
/* benutzten Speicher freigeben */
if( result ) free( result );
FreeArgs( host->rdargs );
if( cargstr ) free( cargstr );
if( array ) (rxc->function)( host, (void **) &array, RXIF_FREE );
if( argb ) free( argb );
}
void ARexxDispatch( struct RexxHost *host )
{
struct RexxMsg *rexxmsg;
while( rexxmsg = (struct RexxMsg *) GetMsg(host->port) )
{
if( rexxmsg->rm_Node.mn_Node.ln_Type == NT_REPLYMSG )
{
FreeRexxCommand( rexxmsg );
--host->replies;
}
else if( ARG0(rexxmsg) )
{
DoRXCommand( host, rexxmsg );
}
}
}
void DoShellCommand( struct RexxHost *host, char *comline, BPTR fhout )
{
struct rxs_command *rxc;
char *argb = NULL, *arg;
LONG *array = NULL;
LONG *argarray;
LONG *resarray;
struct RDArgs *rdargs = NULL;
char *cargstr = NULL;
long rc=10, rc2=0;
rdargs = AllocDosObject( DOS_RDARGS, NULL );
argb = malloc( strlen(comline) + 2 );
if( !rdargs || !argb )
{
rc2 = ERROR_NO_FREE_STORE;
goto dsc_cleanup;
}
/* welches Kommando? */
strcpy( argb, comline );
strcat( argb, "\n" );
arg = argb;
if( !( rxc = ParseRXCommand( &arg ) ) )
{
if( arg = ExpandRXCommand( host, comline ) )
{
free( argb );
if( !(argb = malloc( strlen(arg) + 2 )) )
{
rc2 = ERROR_NO_FREE_STORE;
goto dsc_cleanup;
}
strcpy( argb, arg );
strcat( argb, "\n" );
free( arg );
arg = argb;
rxc = ParseRXCommand( &arg );
}
}
if( !rxc )
{
rc2 = ERROR_NOT_IMPLEMENTED;
goto dsc_cleanup;
}
if( !(rxc->flags & ARB_CF_ENABLED) )
{
rc = -10;
rc2 = (long) "Command disabled";
goto dsc_cleanup;
}
/* Speicher fⁿr Argumente etc. holen */
(rxc->function)( host, (void **) &array, RXIF_INIT );
cargstr = malloc( rxc->args ? 512+strlen(rxc->args) : 512 );
if( !array || !cargstr )
{
rc2 = ERROR_NO_FREE_STORE;
goto dsc_cleanup;
}
argarray = array + 2;
resarray = array + rxc->resindex;
/* Argumente parsen */
*cargstr = '\0';
if( rxc->results )
strcpy( cargstr, "VAR/K,STEM/K" );
if( rxc->args )
{
if( *cargstr )
strcat( cargstr, "," );
strcat( cargstr, rxc->args );
}
if( *cargstr )
{
rdargs->RDA_Source.CS_Buffer = arg;
rdargs->RDA_Source.CS_Length = strlen(arg);
rdargs->RDA_Source.CS_CurChr = 0;
rdargs->RDA_DAList = NULL;
rdargs->RDA_Flags = RDAF_NOPROMPT;
if( !ReadArgs(cargstr, argarray, rdargs) )
{
rc = 10;
rc2 = IoErr();
goto dsc_cleanup;
}
}
/* Funktion aufrufen */
(rxc->function)( host, (void **) &array, RXIF_ACTION );
/* Resultat(e) ausgeben */
if( rxc->results && array[0]==0 && fhout )
{
struct rxs_stemnode *stem, *s;
char *result;
stem = CreateSTEM( rxc, resarray, (char *)argarray[1] );
result = CreateVAR( stem );
if( (long) result == -1L )
{
if( stem > (struct rxs_stemnode *) NULL )
free_stemlist( stem );
rc2 = ERROR_NO_FREE_STORE;
goto dsc_cleanup;
}
if( result )
{
if( argarray[0] )
{
/* VAR */
FPrintf( fhout, "%s = %s\n", argarray[0], result );
free( result );
result = NULL;
}
if( argarray[1] )
{
/* STEM */
for( s = stem; s; s = s->succ )
FPrintf( fhout, "%s = %s\n", s->name, s->value );
if( result ) free( result );
result = NULL;
}
}
/* Nur RESULT, wenn weder VAR noch STEM sein soll */
if( result )
{
FPrintf( fhout, "%s\n", result );
free( result );
}
if( stem > (struct rxs_stemnode *) NULL )
free_stemlist( stem );
}
/* Rⁿckgabewert */
rc = array[0];
rc2 = array[1];
dsc_cleanup:
arg = NULL;
if( rc2 )
{
if( !cargstr ) cargstr = malloc( 512 );
if( !cargstr )
{
arg = "ERROR: Absolutely out of memory";
}
else if( rc > 0 )
{
if( Fault( rc2, "ERROR", cargstr, 512 ) )
arg = cargstr;
else
arg = "ERROR: Unknown Problem";
}
else if( rc < 0 )
{
strcpy( cargstr, "ERROR: " );
strncat( cargstr, (char *) rc2, 500 );
arg = cargstr;
}
}
if( arg ) FPrintf( fhout, "%s\n", arg );
/* benutzten Speicher freigeben */
if( cargstr ) free( cargstr );
if( array ) (rxc->function)( host, (void **) &array, RXIF_FREE );
if( argb ) free( argb );
if( rdargs )
{
FreeArgs( rdargs );
FreeDosObject( DOS_RDARGS, rdargs );
}
}
void CommandShell( struct RexxHost *host, BPTR fhin, BPTR fhout, char *prompt )
{
char comline[512], *s;
struct RexxMsg *rm;
if( !fhin )
return;
host->flags |= ARB_HF_CMDSHELL;
do
{
/* Prompt ausgeben */
if( fhout && prompt )
FPuts( fhout, prompt );
/* Befehl einlesen und abarbeiten */
if( s = FGets(fhin, comline, 512) )
{
while( *s==' ' || *s=='\t' ) s++;
if( *s != '\n' )
DoShellCommand( host, s, fhout );
}
else
{
host->flags &= ~ARB_HF_CMDSHELL;
}
/* Port des Hosts leeren */
while( rm = (struct RexxMsg *) GetMsg(host->port) )
{
/* Reply? */
if( rm->rm_Node.mn_Node.ln_Type == NT_REPLYMSG )
{
FreeRexxCommand( rm );
--host->replies;
}
/* sonst Kommando -> Fehler */
else
{
ReplyRexxCommand( rm, -20, (long)
"CommandShell Port", NULL );
}
}
}
while( host->flags & ARB_HF_CMDSHELL );
}