home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Amiga Elysian Archive
/
AmigaElysianArchive.iso
/
wp_dtp
/
xdme1821.lha
/
XDME
/
drexx.c
< prev
next >
Wrap
C/C++ Source or Header
|
1993-03-30
|
12KB
|
561 lines
/******************************************************************************
MODUL
drexx.c
DESCRIPTION
Another AREXX interface for the XDME. Uses HRexx.c, some tools, I
wrote for a easier AREXX-usage.
This module implements the same commands as "rexx.c", so it works
with a minimum of changes in the real XDME sources.
Because I want to implement a, which is ALWAYS calleble from the
outer world (other tasks), I was forced to made some minor changes
in main.c (marked with "/ * HD " as comment ). Further I had to add
an Activate Window to cmd1.c's QUIT command , because it dosen't
work proper if it was called with a deactivated window.
In addition I added my new commands in the commandtable in
"command.c"
NOTES
BUGS
TODO
EXAMPLES
SEE ALSO
INDEX
HISTORY
dirk 26. Dec 1991 created
******************************************************************************/
/**************************************
Includes
**************************************/
#include "defs.h"
#include "hrexx.h"
#include "rexx/storage.h"
#include "rexx/rxslib.h"
#include "rexx/rexxio.h"
#include "rexx/errors.h"
#define MYDEBUG 0
#include "debug.h"
/**************************************
Globale Variable
**************************************/
Prototype ULONG RexxMask;
Prototype int foundcmd; /* control for implicit ARexx macro invocation */
Prototype int cmderr; /* global command error flag for do_rexx()'s use */
Prototype void openrexx (void);
Prototype void closerexx (void);
Prototype void do_rx (void);
Prototype void do_rx1 (void);
Prototype void do_rx2 (void);
Prototype long do_rxImplied (char *, char *);
Prototype void extern_rexx_command (void);
Prototype void to_port (void);
Prototype void select_window (void);
Prototype void project_info (void);
Prototype int load_project (void);
Prototype void save_project (void);
Prototype void put_rexx_result (void);
Prototype char * get_rexx_result (void);
Prototype long do_rexx (const char * port, const char *fmt, ...);
ULONG RexxMask; /* ArexxPort signalmask for Wait */
int foundcmd; /* control for implicit ARexx macro invocation */
int cmderr; /* global command error flag for do_rexx's use */
static char rexx_result[256]; /* hier wird das Rexxresult untergerbracht */
/**************************************
Interne Defines & Strukturen
**************************************/
/**************************************
Interne Variable
**************************************/
/**************************************
Interne Prototypes
**************************************/
__stkargs static void in_rexx (struct RexxMsg *);
/************************************************************************/
/* lokale Funktionen */
/************************************************************************/
__stkargs static void in_rexx (struct RexxMsg *rmsg)
/*
* this function is called with incomming Rexxmessages, while
* processing SyncRexxCommand
*
* --> rmsg pointer to the RexxMessage
*/
{
long ret;
foundcmd = 0;
*rexx_result = 0;
// currentmsg = (MSG*)rmsg; /* PATCH_RXADD */
ret = !do_command ((char *)ARG0(rmsg));
// currentmsg = NULL; /* PATCH_RXADD */
if (rexx_result[0])
ReplyRexxMsg (rmsg, ret, rexx_result);
else
ReplyRexxMsg (rmsg, ret, 0);
*rexx_result= 0;
do_command ("null"); /* reset foundcommand */
}
/************************************************************************/
/* globale Funktionen */
/************************************************************************/
long do_rexx (const char * port, const char *fmt,...)
/*
* This command transmittes the command, printf-style, to a named
* port.
*
* --> port name of port
* --> fmt printf-like format string for the command
* --> ... the args for the command
*/
{
va_list va;
char macro[256];
va_start (va, fmt);
vsprintf (macro, fmt, va);
va_end (va);
return (SyncRexxCommand (port, macro, rexx_result, sizeof(rexx_result), 0));
}
void put_rexx_result (void)
/*
Copy a string to rexx_result
*/
{
strcpy (rexx_result, av[1]);
}
char * get_rexx_result (void)
/*
Get Contents of rexx_result
*/
{
puts (rexx_result);
return (rexx_result);
}
void openrexx (void)
/* initalizes the Arexx-stuff */
{
int number;
number = 1;
Forbid ();
do
{
sprintf (RexxPortName, "XDME.%d", number ++);
} while (FindPort (RexxPortName) && number < 1000);
Permit ();
RexxMask = OpenRexx (RexxPortName, "XDME", in_rexx, 0, 0);
if (!RexxMask)
exiterr ("Cannot open AREXX-Port");
}
void closerexx (void)
/* shut down the Arexx-stuff */
{
CloseRexx ();
}
void do_rx (void)
/*
* explicit invocation interface between do_command() and do_rexx
* for ARexx macros having NO arguments (i.e., for the "rx" command)
*/
{
do_rexx (0,"%s",av[1]);
}
void do_rx1 (void)
/*
* explicit invocation interface between do_command() and do_rexx
* for ARexx macros having ONE argument (i.e., for the "rx1" command)
*/
{
do_rexx (0,"%s %s",av[1],av[2]);
}
void do_rx2 (void)
/*
* explicit invocation interface between do_command() and do_rexx
* for ARexx macros having TWO arguments (i.e., for the "rx2" command)
*/
{
do_rexx (0,"%s %s %s",av[1],av[2],av[3]);
}
long do_rxImplied (char * cmd,char * args)
/*
* implicit invocation interface between do_command() and do_rexx
* for ARexx macros implicitly called; arbitrary number of arguments
*/
{
return (do_rexx (0,"%s %s",cmd,args));
}
/***********************************************************************/
/*********** New Commands *************/
/***********************************************************************/
void extern_rexx_command (void)
/*
* executes a command, comming in from an external port
*/
{
long ret;
struct RexxMsg * rmsg;
*rexx_result = 0;
// if (Debug) printf("extern_rexx_command\n"); /* */
rmsg = GetRexxMsg ();
// currentmsg = (MSG*)rmsg; /* PATCH_RXADD */
ret = !do_command ((char *)ARG0(rmsg));
// currentmsg = NULL; /* PATCH_RXADD */
if (rexx_result[0])
ReplyRexxMsg (rmsg, ret, rexx_result);
else
ReplyRexxMsg (rmsg, ret, 0);
*rexx_result = 0;
} /* extern_rexx_command */
void to_port (void)
/*
* simply passes a command to another named port
*/
{
do_rexx (av[1], "%s", av[2]);
} /* to_port */
void select_window (void)
/*
* selects another window FIRST LAST NEXT PREVIOUS WINDOW=<NAME> SAVE LOAD
* every command can be abreviated by its first character:
* "select window=cmd1.c" = "select w=cmd1.c"
*/
{
ED * ed = NULL;
static ED * sto_ed = NULL;
switch (av[1][0])
{
case ('l') :
{
if (av[1][1] == 'a')
ed = (ED *)GetTail (&DBase);
else
ed = sto_ed;
break; } /* case ('l') */
case ('f') :
{
ed = (ED *)GetHead (&DBase);
break; } /* case ('f') */
case ('n') :
{
ed = GetPred (Ep);
if (ed == NULL && globalflags.Windowcycling)
{ /* PATCH_NULL */
ed = (ED *)GetHead (&DBase); /* PATCH_NULL */
} /* if */ /* PATCH_NULL */
break; } /* case ('n') */
case ('p') :
{
ed = GetSucc (Ep);
if (ed == NULL && globalflags.Windowcycling)
{ /* PATCH_NULL */
ed = (ED *)GetTail (&DBase); /* PATCH_NULL */
} /* if */ /* PATCH_NULL */
break; } /* case ('p') */
case ('a') :
{
ActivateWindow (Ep->win);
if (globalflags.ActivateToFront)
{ /* PATCH_NULL */
WindowToFront (Ep->win); /* PATCH_NULL */
} /* if */ /* PATCH_NULL */
break; } /* case ('a') */
case ('s') :
{
sto_ed = Ep;
return;
break; } /* case ('s') */
case ('w') :
{
char * ptr;
ptr = av[1];
while (*ptr && *ptr != '=')
ptr ++;
if (*ptr)
ptr ++;
else
break;
D(bug("looking for `%s'\n", ptr));
for (ed=(ED *)GetHead(&DBase); ed; ed=GetSucc(ed))
if (!stricmp (ed->name, ptr)) /* found it */
break;
D(bug("Found %08x\n", ed));
break; } /* case ('w') */
} /* switch (av[1][0]) */
if (ed)
{
switch_ed (ed);
ActivateWindow (ed->win);
if (globalflags.ActivateToFront)
{ /* PATCH_NULL */
WindowToFront (ed->win); /* PATCH_NULL */
} /* if */ /* PATCH_NULL */
} else
{
globalflags.Abortcommand = 1;
}
} /* select_window */
void project_info (void)
/*
* builds the following string:
* path <name> <left> <top> <width> <height> <iconleft> <iconright>
* if Rexx called this string is return as resultstring
*/
{
char path[PATHSIZE]; /* Puffer für Pfad */
getpathto (Ep->dirlock, NULL, path);
/* Read values from Window-Struct */
if (Ep->iconmode)
{
Ep->config.iwinx = Ep->win->LeftEdge;
Ep->config.iwiny = Ep->win->TopEdge;
} else
{
Ep->config.winx = Ep->win->LeftEdge;
Ep->config.winy = Ep->win->TopEdge;
Ep->config.winwidth = Ep->win->Width;
Ep->config.winheight = Ep->win->Height;
}
sprintf (rexx_result, "\"%s\" \"%s\" %d %d %d %d %d %d %d",
path, Ep->name,
Ep->config.winx,
Ep->config.winy,
Ep->config.winwidth,
Ep->config.winheight,
Ep->config.iwinx,
Ep->config.iwiny,
Ep->line
);
} /* project_info */
void save_project (void)
/*
* saves all opened files in the directory of the currently active
* editor to a file name XDMEArgs.projectfilename.
* The lines are in the same format as returned from project_info
*/
{
ED * ed; /* Currenteditor */
ED * act_ed; /* active Editor */
BPTR old_lock; /* Active dirlock */
BPTR file; /* our PRJ file */
old_lock = CurrentDir (Ep->dirlock); /* change dir */
act_ed = Ep; /* save active Editor */
file = Open (XDMEArgs.projectfilename, MODE_NEWFILE);
if (file)
{
Write (file, "# path name x y w h ix iy line\n", 31L);
for (ed=(ED *)GetHead(&DBase); ed; ed=(ED *)GetSucc((struct Node *)ed))
{
switch_ed (ed); /* change current ed */
project_info (); /* build info text */
Write (file, rexx_result, strlen (rexx_result));
Write (file, "\n", 1L);
}
Close (file);
} /* if (file) */
switch_ed (act_ed); /* restore actuall editor */
CurrentDir (old_lock); /* go back to old dir */
} /* project_save */
int load_project (void)
{
FILE * file;
char path[PATHSIZE]; /* Puffer für Pfad */
char name[60]; /* file name */
char * ptr;
long t, il, it, line; /* window & icon & line */
file = fopen (XDMEArgs.projectfilename, "r"); /* Open ProjectFile */
if (file)
{
while (fgets (tmp_buffer, 256, file))
{
if (*tmp_buffer == '#')
continue;
ptr = skip_whitespace (tmp_buffer);
if (*ptr == '"')
{
ptr ++;
for (t=0; *ptr != '"'; )
path[t ++] = *ptr ++;
ptr ++;
} else
for (t=0; !isspace(*ptr); )
path[t ++] = *ptr ++;
path[t] = 0;
ptr = skip_whitespace (ptr);
if (*ptr == '"')
{
ptr ++;
for (t=0; *ptr != '"'; )
name[t ++] = *ptr ++;
ptr ++;
} else
for (t=0; !isspace(*ptr); )
name[t ++] = *ptr ++;
name[t] = 0;
av[1] = ptr;
do_openwindow ();
av[1] = path;
do_cd ();
av[0] = "newfile";
av[1] = name;
do_edit ();
sscanf (ptr, " %d %d %d %d %d %d %d\n",
&t, &t, &t, &t, &il, &it, &line);
if (line >= Ep->lines)
line = Ep->lines - 1;
Ep->line = line;
text_load ();
text_adjust (FALSE);
Ep->config.iwinx = il;
Ep->config.iwiny = it;
do_iconify ();
}
fclose (file);
t = TRUE;
} else
{
warn ("projectload: Cannot find file `%s'", XDMEArgs.projectfilename);
t = FALSE;
}
return (t);
} /* load_project */
/******************************************************************************
***** ENDE drexx.c
******************************************************************************/