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