int SysCall main(int argc, char **argv)
{
char fn[2][BUFFERLEN];
int silent = 0;
int j = 0;
HINSTANCE hDll=NULL;
hDll = LoadLibrary(DLLNAME);
for (j=1; j<argc; j++)
{
if (((argv[j][0] == '/') || (argv[j][0] == '-'))
&& ((argv[j][1] == 's') || (argv[j][1] == 'S'))) silent = j;
}
if (!silent)
{
char *ptr = RexxGetVersionInformation();
if (ptr) {
printf(ptr, "Tokenizer");
printf("\n");
RexxFreeMemory(ptr);
}
}
/* check arguments: at least 1 argument, max. 2, /s must be last */
if ((argc < 2) || (argc > 4) || /* invalid no. of args */
(silent && (argc == 2)) || /* only /s */
(silent && (silent+1 != argc)) || /* /s not last arg */
(!silent && (argc == 4))) /* 3 args, no /s */
{
if (argc > 2) {
DisplayError(hDll, Error_REXXC_cmd_parm_incorrect);
}
DisplayError(hDll, Error_REXXC_wrongNrArg);
DisplayError(hDll, Error_REXXC_SynCheckInfo);
if (hDll) FreeLibrary(hDll);
exit(-1);
}
strcpy(fn[0], argv[1]);
if (argc >= 3) strcpy(fn[1], argv[2]);
if ( ((argc>3) || ((argc==3) && !silent)) &&
(strcmp(strupr(fn[0]), strupr(fn[1])) == 0))
{
DisplayError(hDll, Error_REXXC_outDifferent);
if (hDll) FreeLibrary(hDll);
exit(-2);
}
if (hDll) FreeLibrary(hDll);
if ((argc == 2) || ((argc==3) && silent) ) /* just doing a syntax check? */
/* go perform the translation */
return RexxTranslateProgram(argv[1], NULL, NULL);
else /* translate and save the output */
return RexxTranslateProgram(argv[1], argv[2], NULL);
}
int SysCall main(int argc, char **argv)
{
int silent = 0;
int j = 0;
for (j = 1; j < argc; j++)
{
if (((argv[j][0] == '/') || (argv[j][0] == '-'))
&& ((argv[j][1] == 's') || (argv[j][1] == 'S'))) silent = j;
}
if (!silent)
{
char *ptr = RexxGetVersionInformation();
printf("%s\n", ptr);
RexxFreeMemory(ptr);
}
/* check arguments: at least 1 argument, max. 2, /s must be last */
if ((argc < 2) || (argc > 4) || /* invalid no. of args */
(silent && (argc == 2)) || /* only /s */
(silent && (silent+1 != argc)) || /* /s not last arg */
(!silent && (argc == 4))) /* 3 args, no /s */
{
if (argc > 2)
{
DisplayError(Error_REXXC_cmd_parm_incorrect);
}
DisplayError(Error_REXXC_wrongNrArg);
DisplayError(Error_REXXC_SynCheckInfo);
exit(-1);
}
if ( ((argc>3) || ((argc==3) && !silent)) &&
(stricmp(argv[1], argv[2]) == 0))
{
DisplayError(Error_REXXC_outDifferent);
exit(-2);
}
if ((argc == 2) || ((argc==3) && silent) )
{
/* go perform the translation */
return RexxTranslateProgram(argv[1], NULL, NULL);
}
else /* translate and save the output */
{
return RexxTranslateProgram(argv[1], argv[2], NULL);
}
}
//
// MAIN program
//
int __cdecl main(int argc, char *argv[]) {
short rexxrc = 0; /* return code from rexx */
int i; /* loop counter */
int rc; /* actually running program RC */
const char *program_name; /* name to run */
char arg_buffer[8192]; /* starting argument buffer */
char *cp; /* option character pointer */
CONSTRXSTRING arguments; /* rexxstart argument */
size_t argcount;
RXSTRING rxretbuf; // program return buffer
BOOL from_string = FALSE; /* running from command line string? */
BOOL real_argument = TRUE; /* running from command line string? */
RXSTRING instore[2];
RexxInstance *pgmInst;
RexxThreadContext *pgmThrdInst;
RexxArrayObject rxargs, rxcargs;
RexxDirectoryObject dir;
RexxObjectPtr result;
rc = 0; /* set default return */
/*
* Convert the input array into a single string for the Object REXX
* argument string. Initialize the RXSTRING variable to point to this
* string. Keep the string null terminated so we can print it for debug.
* First argument is name of the REXX program
* Next argument(s) are parameters to be passed
*/
arg_buffer[0] = '\0'; /* default to no argument string */
program_name = NULL; /* no program to run yet */
for (i = 1; i < argc; i++) /* loop through the arguments */
{
/* is this an option switch? */
if ((*(cp=*(argv+i)) == '-' || *cp == '/')) {
switch (*++cp) {
case 'e':
case 'E': /* execute from string */
if (from_string == FALSE) { /* only treat 1st -e differently */
from_string = TRUE;
if ( argc == i+1 ) {
break;
}
program_name = "INSTORE";
instore[0].strptr = argv[i+1];
instore[0].strlength = strlen(instore[0].strptr);
instore[1].strptr = NULL;
instore[1].strlength = 0;
real_argument = FALSE;
}
break;
case 'v':
case 'V': { /* version display */
char *ptr = RexxGetVersionInformation();
if (ptr)
{
fprintf(stdout, ptr);
fprintf(stdout, "\n");
RexxFreeMemory(ptr);
}
return 0;
}
default: /* ignore other switches */
break;
}
}
else /* convert into an argument string */
{
if (program_name == NULL) { /* no name yet? */
program_name = argv[i]; /* program is first non-option */
break; /* end parsing after program_name has been resolved */
}
else if ( real_argument ) { /* part of the argument string */
if (arg_buffer[0] != '\0') { /* not the first one? */
strcat(arg_buffer, " "); /* add an blank */
}
strcat(arg_buffer, argv[i]); /* add this to the argument string */
}
real_argument = TRUE;
}
}
if (program_name == NULL) {
/* give a simple error message */
#undef printf
printf("\n");
fprintf(stderr,"Syntax is \"rexx filename [arguments]\"\n");
fprintf(stderr,"or \"rexx -e program_string [arguments]\"\n");
fprintf(stderr,"or \"rexx -v\".\n");
return -1;
}
else { /* real program execution */
getArguments(NULL, GetCommandLine(), &argcount, &arguments);
rxretbuf.strlength = 0L; /* initialize return to empty */
#ifdef REXXC_DEBUG
printf("program_name = %s\n", program_name);
printf("argv 0 = %s\n", argv[0]);
printf("argv 1 = %s\n", argv[1]);
printf("argv 2 = %s\n", argv[2]);
printf("argument.strptr = %s\n", argument.strptr);
printf("argument.strlenth = %lu\n", argument.strlength);
#endif
if (from_string) {
/* Here we call the interpreter. We don't really need to use */
/* all the casts in this call; they just help illustrate */
/* the data types used. */
rc=REXXSTART(argcount, /* number of arguments */
&arguments, /* array of arguments */
program_name, /* name of REXX file */
instore, /* rexx code from command line */
"CMD", /* Command env. name */
RXCOMMAND, /* Code for how invoked */
NULL,
&rexxrc, /* Rexx program output */
&rxretbuf ); /* Rexx program output */
/* rexx procedure executed*/
if ((rc==0) && rxretbuf.strptr) {
RexxFreeMemory(rxretbuf.strptr); /* Release storage only if */
}
freeArguments(NULL, &arguments);
}
else {
RexxCreateInterpreter(&pgmInst, &pgmThrdInst, NULL);
// configure the traditional single argument string
if ( arguments.strptr != NULL )
{
rxargs = pgmThrdInst->NewArray(1);
pgmThrdInst->ArrayPut(rxargs, pgmThrdInst->String(arguments.strptr), 1);
}
else
{
rxargs = pgmThrdInst->NewArray(0);
}
// set up the C args into the .local environment
dir = (RexxDirectoryObject)pgmThrdInst->GetLocalEnvironment();
if ( argc > 2 )
{
rxcargs = pgmThrdInst->NewArray(argc - 2);
}
else
{
rxcargs = pgmThrdInst->NewArray(0);
}
for (i = 2; i < argc; i++)
{
pgmThrdInst->ArrayPut(rxcargs,
pgmThrdInst->NewStringFromAsciiz(argv[i]),
i - 1);
}
pgmThrdInst->DirectoryPut(dir, rxcargs, "SYSCARGS");
// call the interpreter
result = pgmThrdInst->CallProgram(program_name, rxargs);
// display any error message if there is a condition.
// if there was an error, then that will be our return code.
// Although the return is a wholenumber_t we know there is no error
// code too big to fit in an int.
rc = (int)pgmThrdInst->DisplayCondition();
if (rc != 0)
{
pgmInst->Terminate();
return -rc; // well, the negation of the error number is the return code
}
// now handle any potential return value
if (result != NULL) {
pgmThrdInst->ObjectToInt32(result, &rc);
}
pgmInst->Terminate();
return rc;
}
}
return rc ? rc : rexxrc; // rexx program return cd
}