workbench/c/R/main.c

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