workbench/c/R/main.c

   1 /*
   2     Copyright © 2012, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define DEBUG 0
   7 #include <aros/debug.h>
   8
   9 #include <proto/exec.h>
  10 #include <proto/dos.h>
  11
  12 #include <stdlib.h>
  13 #include <stdio.h>
  14 #include <string.h>
  15 #include <ctype.h>
  16
  17 #include "r.h"
  18 #include "locale.h"
  19
  20 #define ARG_TEMPLATE "FILENAME,PROFILE/K,NOGUI/S,ARGUMENTS/F"
  21 #define CMD_TMPLATE_SIZE (2000)
  22
  23 APTR poolmem;
  24
  25 enum
  26 {
  27     ARG_FILENAME,
  28     ARG_PROFILE,
  29     ARG_NOGUI,
  30     ARG_ARGUMENTS,
  31     ARG_COUNT
  32 };
  33
  34 // functions
  35 static void clean_exit(struct Req *req, CONST_STRPTR s)
  36 {
  37     LONG retval = RETURN_OK;
  38
  39     if (s)
  40     {
  41         retval = RETURN_FAIL;
  42         PutStr(s);
  43     }
  44     if (req)
  45     {
  46         if (req->rda) FreeArgs(req->rda);
  47     }
  48     cleanup_gui();
  49     DeletePool(poolmem);
  50     exit(retval);
  51 }
  52
  53 static struct Req *alloc_req(void)
  54 {
  55     return AllocPooled(poolmem, sizeof (struct Req));
  56 }
  57
  58 static BOOL handle_args(struct Req *req, int argc, char **argv)
  59 {
  60     if (argc)
  61     {
  62         IPTR args[ARG_COUNT] = {(IPTR)"R", 0, 0, 0};
  63
  64         req->rda = ReadArgs(ARG_TEMPLATE, args, NULL);
  65         if (!req->rda)
  66         {
  67             PrintFault(IoErr(), argv[0]);
  68             return FALSE;
  69         }
  70
  71         req->filename = (STRPTR)args[ARG_FILENAME];
  72         req->profile = (STRPTR)args[ARG_PROFILE];
  73         req->nogui = args[ARG_NOGUI] ? TRUE : FALSE;
  74         req->arguments = (STRPTR)args[ARG_ARGUMENTS];
  75     }
  76     else
  77     {
  78         return FALSE;
  79         // FIXME: it should be possible to use R as default tool
  80         // of another command
  81     }
  82     return TRUE;
  83 }
  84
  85
  86 // return TRUE if name exists and is not a directory
  87 static BOOL is_file(CONST_STRPTR name)
  88 {
  89     BOOL retval = FALSE;
  90
  91     if (name && name[0])
  92     {
  93         struct FileInfoBlock *fib = AllocDosObject(DOS_FIB, NULL);
  94         if (fib)
  95         {
  96             BPTR lock = Lock(name, SHARED_LOCK);
  97             if (lock)
  98             {
  99                 if (Examine(lock, fib))
 100                 {
 101                     if (fib->fib_DirEntryType < 0)
 102                     {
 103                         retval = TRUE;
 104                     }
 105                 }
 106                 UnLock(lock);
 107             }
 108             FreeDosObject(DOS_FIB, fib);
 109         }
 110     }
 111     return retval;
 112 }
 113
 114
 115 // search for the command. It must
 116 // be an absolute path, exist in the current directory
 117 // or exist in "C:".
 118 static BOOL check_exist(struct Req *req)
 119 {
 120     BOOL retval = FALSE;
 121
 122     if (req->filename == NULL)
 123         return FALSE;
 124
 125     if (strchr(req->filename, ':')) // absolute path
 126     {
 127         if (is_file(req->filename))
 128         {
 129             D(bug("[R] command found by absolute path\n"));
 130             retval = TRUE;
 131         }
 132     }
 133     else if (strchr(req->filename, '/') == NULL) // not in a sub-dir
 134     {
 135         if (is_file(req->filename)) // in current directory
 136         {
 137             D(bug("[R] command found in current directory\n"));
 138             retval = TRUE;
 139         }
 140         else // in C:
 141         {
 142             BPTR lock = Lock("C:", SHARED_LOCK);
 143             if (lock)
 144             {
 145                 BPTR olddir = CurrentDir(lock);
 146                 if (is_file(req->filename))
 147                 {
 148                     D(bug("[R] command found in C:\n"));
 149                     retval = TRUE;
 150                 }
 151                 CurrentDir(olddir);
 152                 UnLock(lock);
 153             }
 154
 155         }
 156     }
 157
 158     return retval;
 159 }
 160
 161
 162 // execute the command with "?" option and read the command template
 163 static BOOL get_template(struct Req *req)
 164 {
 165     BOOL retval = FALSE;
 166
 167     BPTR input_fh = BNULL;
 168     BPTR output_fh = BNULL;
 169
 170     TEXT out_file_name[30];
 171     TEXT in_file_name[30];
 172     TEXT *cmd = NULL;
 173     ULONG cmd_len = 0;
 174
 175     LONG i;
 176     __unused LONG cmd_res = 0;
 177
 178     if (req->filename == NULL)
 179     {
 180         goto cleanup;
 181     }
 182
 183     cmd_len = strlen(req->filename) + 20;
 184     cmd = AllocPooled(poolmem, cmd_len);
 185     if (cmd == NULL)
 186     {
 187         goto cleanup;
 188     }
 189
 190     for (i = 0; i < 20 && output_fh == BNULL; i++)
 191     {
 192         sprintf(out_file_name, "t:%08u.request.outfile", (unsigned int)i);
 193         output_fh = Open(out_file_name, MODE_NEWFILE);
 194     }
 195     if (output_fh == BNULL)
 196     {
 197         goto cleanup;
 198     }
 199
 200     for (i = 0; i < 20 && input_fh == BNULL; i++)
 201     {
 202         sprintf(in_file_name, "t:%08u.request.infile", (unsigned int)i);
 203         input_fh = Open(in_file_name, MODE_NEWFILE);
 204     }
 205     if (input_fh == BNULL)
 206     {
 207         goto cleanup;
 208     }
 209     Close(input_fh);
 210     input_fh = Open(in_file_name, MODE_OLDFILE);
 211     if (input_fh == BNULL)
 212     {
 213         goto cleanup;
 214     }
 215
 216     // append "= ?" to the command to make ReadArgs fail so
 217     // that the command prints the template and stops
 218     strlcpy(cmd, req->filename, cmd_len);
 219     strlcat(cmd, " = ?", cmd_len);
 220
 221     // shut up DOS error message
 222     struct Process *me = (struct Process*)FindTask(NULL);
 223     APTR oldwin = me->pr_WindowPtr;
 224     me->pr_WindowPtr = (APTR)-1;
 225
 226     // Execute the command
 227     cmd_res = Execute(cmd, input_fh, output_fh);
 228     D(bug("[R] Execute() returned: %d\n", cmd_res));
 229
 230     // restore window ptr
 231     me->pr_WindowPtr = oldwin;
 232
 233     req->cmd_template = AllocPooled(poolmem, CMD_TMPLATE_SIZE); // FIXME get mem size from file size
 234     if (req->cmd_template == NULL)
 235     {
 236         goto cleanup;
 237     }
 238
 239     // go to the beginning of the output file and read the template
 240     Seek(output_fh, 0, OFFSET_BEGINNING);
 241     if (FGets(output_fh, req->cmd_template, CMD_TMPLATE_SIZE))
 242     {
 243         D(bug("[R] template read: %s\n", req->cmd_template));
 244         retval = TRUE;
 245     }
 246
 247 cleanup:
 248     if (input_fh)
 249     {
 250         Close(input_fh);
 251         DeleteFile(in_file_name);
 252     }
 253     if (output_fh)
 254     {
 255         Close(output_fh);
 256         DeleteFile(out_file_name);
 257     }
 258
 259     FreePooled(poolmem, cmd, cmd_len);
 260
 261     return retval;
 262 }
 263
 264
 265 static BOOL parse_template(struct Req *req)
 266 {
 267     TEXT *chr;
 268     LONG len;
 269     LONG arg;
 270
 271     if (req->cmd_template[0] == '\0')
 272         return FALSE;
 273
 274     // count number of arguments
 275     for
 276     (
 277         req->arg_cnt = 1, chr = req->cmd_template;
 278         *chr != '\0' && req->arg_cnt < 50;
 279         chr++
 280     )
 281     {
 282         if (*chr == ',')
 283         {
 284             req->arg_cnt++;
 285         }
 286     }
 287
 288     D(bug("[R/parse_template] args found %d\n", req->arg_cnt));
 289
 290     req->cargs = AllocPooled(poolmem, sizeof (struct CArg) * req->arg_cnt);
 291     if (req->cargs == NULL)
 292     {
 293         return FALSE;
 294     }
 295
 296     for
 297     (
 298         arg = 0, chr = req->cmd_template;
 299         arg < req->arg_cnt;
 300         chr++
 301     )
 302     {
 303         // read name
 304         TEXT *name_start = chr;
 305         while (1)
 306         {
 307             if (isalnum(*chr))
 308             {
 309                 chr++;
 310                 continue;
 311             }
 312             else if (*chr == '=')
 313             {
 314                 // we are only interested in the part after the "=".
 315                 chr++;
 316                 name_start = chr;
 317                 continue;
 318             }
 319             break;
 320         }
 321
 322         len = chr - name_start;
 323         if (len == 0)
 324             return FALSE;
 325
 326         if (len >= 35)
 327             len = 35;
 328
 329         req->cargs[arg].argname = AllocPooled(poolmem, len + 1);
 330         if (req->cargs[arg].argname == NULL)
 331         {
 332             return FALSE;
 333         }
 334         memcpy(req->cargs[arg].argname, name_start, len);
 335         req->cargs[arg].argname[len] = '\0';
 336
 337         // read modifiers
 338         while (*chr == '/')
 339         {
 340             switch (*(chr + 1))
 341             {
 342                 case 'A':
 343                     req->cargs[arg].a_flag = TRUE;
 344                     chr++;
 345                     break;
 346                 case 'F':
 347                     req->cargs[arg].f_flag = TRUE;
 348                     chr++;
 349                     break;
 350                 case 'K':
 351                     req->cargs[arg].k_flag = TRUE;
 352                     chr++;
 353                     break;
 354                 case 'M':
 355                     req->cargs[arg].m_flag = TRUE;
 356                     chr++;
 357                     break;
 358                 case 'N':
 359                     req->cargs[arg].n_flag = TRUE;
 360                     chr++;
 361                     break;
 362                 case 'S':
 363                     req->cargs[arg].s_flag = TRUE;
 364                     chr++;
 365                     break;
 366                 case 'T':
 367                     req->cargs[arg].t_flag = TRUE;
 368                     chr++;
 369                     break;
 370                 default:
 371                     return FALSE;
 372                     break;
 373             }
 374             chr++;
 375         }
 376         arg++;
 377         if (*chr != ',')
 378             break;
 379     }
 380     return TRUE;
 381 }
 382
 383
 384 // create the command line from the selected options
 385 static void execute_command(struct Req *req)
 386 {
 387     ULONG i;
 388     CONST_STRPTR str;
 389     TEXT *cmd;
 390
 391     ULONG cmd_size = strlen(req->filename) + 5;
 392     for (i = 0; i < req->arg_cnt; i++)
 393     {
 394         cmd_size += strlen(req->cargs[i].argname) + 5;
 395         if (!req->cargs[i].s_flag && !req->cargs[i].t_flag)
 396         {
 397             cmd_size += strlen(get_gui_string(&req->cargs[i])) + 5;
 398         }
 399     }
 400
 401     cmd = AllocPooled(poolmem, cmd_size);
 402     if (cmd == NULL)
 403     {
 404         return;
 405     }
 406
 407     strcpy(cmd, req->filename);
 408
 409     for (i = 0; i < req->arg_cnt; i++)
 410     {
 411         if (req->cargs[i].s_flag || req->cargs[i].t_flag)
 412         {
 413             if (get_gui_bool(&req->cargs[i]))
 414             {
 415                 strcat(cmd, " ");
 416                 strcat(cmd, req->cargs[i].argname);
 417             }
 418         }
 419         else if (req->cargs[i].n_flag)
 420         {
 421             str = get_gui_string(&req->cargs[i]);
 422             if (str[0] != '\0')
 423             {
 424                 strcat(cmd, " ");
 425                 strcat(cmd, req->cargs[i].argname);
 426                 strcat(cmd, " ");
 427                 strcat(cmd, str);
 428             }
 429         }
 430         else
 431         {
 432             BOOL quote = FALSE;
 433             str = get_gui_string(&req->cargs[i]);
 434             if (str[0] != '\0')
 435             {
 436                 // do we have a space character in the string?
 437                 // if yes: quote it.
 438                 // For /M the quotes are already set by the GUI
 439                 if (!req->cargs[i].m_flag && strchr(str, ' ') && str[0] != '\"')
 440                 {
 441                     quote = TRUE;
 442                 }
 443                 strcat(cmd, " ");
 444                 strcat(cmd, req->cargs[i].argname);
 445                 strcat(cmd, " ");
 446                 if (quote)
 447                 {
 448                     strcat(cmd, "\"");
 449                 }
 450                 strcat(cmd, str);
 451                 if (quote)
 452                 {
 453                     strcat(cmd, "\"");
 454                 }
 455             }
 456         }
 457     }
 458
 459     D(bug("[R] executing command %s\n", cmd));
 460     LONG result = System
 461     (
 462         cmd,
 463         NULL
 464     );
 465     if (result)
 466     {
 467         Printf(_(MSG_ERROR_RETURN), req->filename, result);
 468     }
 469 }
 470
 471
 472 int main(int argc, char **argv)
 473 {
 474     poolmem = CreatePool(MEMF_ANY | MEMF_CLEAR, 2000, 2000);
 475     if (poolmem == NULL)
 476         clean_exit(NULL, _(MSG_ERROR_POOL));
 477
 478     struct Req *req = alloc_req();
 479     if (req == NULL)
 480         clean_exit(req, _(MSG_ERROR_STRUCT));
 481
 482     D(bug("[R/main] req %p\n", req));
 483
 484     if (! handle_args(req, argc, argv))
 485         clean_exit(req, _(MSG_ERROR_ARGS));
 486
 487     if (! check_exist(req))
 488         clean_exit(req, _(MSG_ERROR_NOTFOUND));
 489
 490     if (! get_template(req))
 491         clean_exit(req, _(MSG_ERROR_TMPLT_GET));
 492
 493     if (! parse_template(req))
 494         clean_exit(req, _(MSG_ERROR_TMPLT_PARSE));
 495
 496     if (! create_gui(req))
 497         clean_exit(req, _(MSG_ERROR_GUI));
 498
 499     if (! set_defaults(req))
 500         clean_exit(req, _(MSG_ERROR_DEFAULTS));
 501
 502     if (handle_gui(req))
 503     {
 504         execute_command(req);
 505     }
 506
 507     clean_exit(req, NULL);
 508
 509     return RETURN_OK;
 510 }