compiler/autoinit/commandline.c

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