compiler/autoinit/commandline.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5 #include <dos/dos.h>
   6 #include <exec/memory.h>
   7 #include <proto/exec.h>
   8 #include <proto/dos.h>
   9 #include <aros/symbolsets.h>
  10 #include <aros/autoinit.h>
  11 #include <aros/startup.h>
  12
  13 #define DEBUG 0
  14 #include <aros/debug.h>
  15
  16 #include "autoinit_intern.h"
  17
  18 int __nocommandline __attribute__((weak)) = 0;
  19
  20 extern char *__argstr;
  21 extern ULONG __argsize;
  22
  23 extern char **__argv;
  24 extern int  __argc;
  25
  26 static char *__args;
  27 static int  __argmax;
  28
  29 static void process_cmdline(int *argc, char *args, char *argv[]);
  30
  31 static void __initcommandline(struct ExecBase *SysBase)
  32 {
  33     char *ptr    = NULL;
  34
  35     if (WBenchMsg) {
  36         __startup_entries_next();
  37         return;
  38     }
  39
  40     if (__argsize)
  41     {
  42         ULONG size;
  43
  44         /* Copy args into buffer */
  45         if (!(__args = AllocMem(__argsize+1, MEMF_ANY)))
  46             return;
  47
  48         ptr = __args;
  49         size= __argsize;
  50         while (size--)
  51             *ptr++ = *__argstr++;
  52         *ptr = 0;
  53
  54         /* Find out how many arguments we have */
  55         process_cmdline(&__argmax, __args, NULL);
  56
  57         if (!(__argv = AllocMem (sizeof (char *) * (__argmax+1), MEMF_ANY | MEMF_CLEAR)) )
  58             return;
  59
  60         D(bug("arg(%d)=\"%s\", argmax=%d\n", __argsize, __args, __argmax));
  61
  62         /* create argv */
  63         process_cmdline(&__argc, __args, __argv);
  64     }
  65     else
  66     {
  67         __argmax = 1;
  68         __argc = 1;
  69         if (!(__argv = AllocMem (sizeof (char *)*2, MEMF_CLEAR | MEMF_ANY)))
  70             return;
  71     }
  72
  73     /*
  74      * get program name
  75      */
  76      __argv[0] = __get_command_name();
  77
  78 #if DEBUG /* Debug argument parsing */
  79
  80     kprintf("argc = %d\n", __argc);
  81     {
  82         int t;
  83         for (t=0; t<__argc; t++)
  84             kprintf("argv[%d] = \"%s\"\n", t, __argv[t]);
  85     }
  86
  87 #endif
  88
  89     __startup_entries_next();
  90
  91     if (WBenchMsg != NULL)
  92         return;
  93
  94     if (__argv)
  95         FreeMem(__argv, sizeof (char *) * (__argmax+1));
  96
  97     if (__args)
  98         FreeMem(__args, __argsize+1);
  99 }
 100
 101 static BOOL is_space(char c)
 102 {
 103         switch(c)
 104         {
 105         case ' ':
 106         case '\n':
 107         case '\t':
 108         case '\v':
 109         case '\f':
 110         case '\r':
 111                 return TRUE;
 112         default:
 113                 return FALSE;
 114         }
 115 }
 116
 117 static BOOL is_escape(char c)
 118 {
 119         if(c == '*')
 120                 return TRUE;
 121         else
 122                 return FALSE;
 123 }
 124
 125 static BOOL is_final_quote(char *ptr)
 126 {
 127         if(*ptr == '\"' && (ptr[1] == '\0' || is_space(ptr[1])))
 128                 return TRUE;
 129         else
 130                 return FALSE;
 131 }
 132
 133 static void process_cmdline(int *pargc, char *args, char *argv[])
 134 {
 135         char *ptr = args;
 136         char *arg;
 137         int argc = 1;
 138
 139         while(TRUE)
 140         {
 141                 /* skip leading white spaces */
 142                 while(is_space(*ptr))
 143                         ptr++;
 144
 145                 if(*ptr == '\0')
 146                         break;
 147
 148                 argc++;
 149                 if(*ptr == '\"')
 150                 {
 151                         /* quoted parameter starts here */
 152                         ptr++;
 153
 154                         /* store pointer to the parameter */
 155                         if(argv)
 156                                 argv[argc-1] = ptr;
 157
 158                         /* unescape quoted parameter */
 159                         arg = ptr;
 160                         while(!(*ptr == '\0' || is_final_quote(ptr)))
 161                         {
 162                                 if(argv)
 163                                 {
 164                                         /* unescaping */
 165                                         if(is_escape(*ptr))
 166                                         {
 167                                                 ptr++;
 168                                                 switch(*ptr)
 169                                                 {
 170                                                 case 'e':
 171                                                 case 'E':
 172                                                         *arg++ = '\033';
 173                                                         break;
 174                                                 case 'N':
 175                                                 case 'n':
 176                                                         *arg++ = '\n';
 177                                                         break;
 178                                                 case '\0':
 179                                                         break;
 180                                                 default:
 181                                                         *arg++ = *ptr;
 182                                                 }
 183                                                 ptr++;
 184                                         }
 185                                         else
 186                                                 *arg++ = *ptr++;
 187                                 }
 188                                 else
 189                                 {
 190                                         /* don't touch anything, just skip escapes */
 191                                         if(is_escape(*ptr))
 192                                         {
 193                                                 ptr++;
 194                                                 if(*ptr != '\0')
 195                                                         ptr++;
 196                                         }
 197                                         else
 198                                                 ptr++;
 199                                 }
 200                         }
 201                         /* skip final quote */
 202                         if(*ptr != '\0')
 203                                 ptr++;
 204                         /* quoted parameter ends here */
 205                         if(argv)
 206                                 *arg = '\0';
 207                 }
 208                 else
 209                 {
 210                         /* unquoted parameter starts here */
 211
 212                         /* store pointer to the parameter */
 213                         if(argv)
 214                                 argv[argc-1] = ptr;
 215
 216                         /* no escaping, just find the end */
 217                         while(!(*ptr == '\0' || is_space(*ptr)))
 218                                 ptr++;
 219
 220                         /* stop processing if we reached the end of argument string */
 221                         if(*ptr == '\0')
 222                                 break;
 223
 224                         /* unquoted parameter ends here */
 225                         if(argv)
 226                                 *ptr++ = '\0';
 227                 }
 228         }
 229         /* store the number of arguments */
 230         *pargc = argc;
 231 }
 232
 233 ADD2SET(__initcommandline, PROGRAM_ENTRIES, -10);