Subversion Repositories Kolibri OS

#include

#include

void _exit(int code)

{

 __asm__ __volatile__("int $0x40"::"a"(-1));

 for(;;);

}

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#define ds _my_ds()

extern char __menuet__app_param_area[];

extern char __menuet__app_path_area[];

static void * c1xmalloc(size_t s)

{

 void *q = malloc(s);

 if (q == 0)

 {

#define err(x)

  err("No memory to gather arguments\r\n");

  _exit(1);

 }

 return q;

}

static int atohex(char *s)

{

  int rv = 0;

  while (*s)

  {

    int v = *s - '0';

    if (v > 9)

      v -= 7;

    v &= 15; /* in case it's lower case */

    rv = rv*16 + v;

    s++;

  }

  return rv;

}

typedef struct Arg {

  char *arg;

  char **arg_globbed;

  struct ArgList *arg_file;

  struct Arg *next;

  int was_quoted;

} Arg;

typedef struct ArgList {

  int argc;

  Arg **argv;

} ArgList;

static Arg *new_arg(void)

{

  Arg *a = (Arg *)c1xmalloc(sizeof(Arg));

  memset(a, 0, sizeof(Arg));

  return a;

}

static void delete_arglist(ArgList *al);

static void delete_arg(Arg *a)

{

  if (a->arg) free(a->arg);

  if (a->arg_globbed)

  {

    int i;

    for (i=0; a->arg_globbed[i]; i++)

      free(a->arg_globbed[i]);

    free(a->arg_globbed);

  }

  if (a->arg_file)

    delete_arglist(a->arg_file);

  free(a);

}

static ArgList * new_arglist(int count)

{

  ArgList *al = (ArgList *)c1xmalloc(sizeof(ArgList));

  al->argc = count;

  al->argv = (Arg **)c1xmalloc((count+1)*sizeof(Arg *));

  memset(al->argv, 0, (count+1)*sizeof(Arg *));

  return al;

}

static void delete_arglist(ArgList *al)

{

  int i;

  for (i=0; iargc; i++)

    delete_arg(al->argv[i]);

  free(al->argv);

  free(al);

}

static char * parse_arg(char *bp, char *last, int unquote, size_t *len, int *was_quoted)

{

  char *ep = bp, *epp = bp;

  int quote=0;

  while ((quote || !isspace(*(unsigned char *)ep)) && ep < last)

  {

    if (quote && *ep == quote)

    {

      quote = 0;

      if (!unquote)

	*epp++ = *ep;

      ep++;

    }

    else if (!quote && (*ep == '\'' || *ep == '"'))

    {

      quote = *ep++;

      if (!unquote)

	*epp++ = quote;

    }

    else if (*ep == '\\' && strchr("'\"", ep[1]) && ep < last-1)

    {

      if (!unquote)

	*epp++ = *ep;

      ep++;

      *epp++ = *ep++;

      /* *was_quoted = 1;  - This makes no sense. */

    }

    else

    {

      if ((quote && (strchr("[?*", *ep) || strncmp(ep, "...", 3) == 0))

	  && unquote)

	*was_quoted = 1;

      *epp++ = *ep++;

    }

  }

  *len = epp - bp;

  return ep;

}

static ArgList * parse_bytes(char *bytes, int length, int unquote)

{

  int largc, i;

  Arg *a, **anext, *afirst;

  ArgList *al;

  char *bp=bytes, *ep, *last=bytes+length;

  anext = &afirst;

  largc = 0;

  while (bp

  {

    size_t arg_len;

    while (isspace(*(unsigned char *)bp) && bp < last)

      bp++;

    if (bp == last)

      break;

    *anext = a = new_arg();

    ep = parse_arg(bp, last, unquote, &arg_len, &(a->was_quoted));

    anext = &(a->next);

    largc++;

    a->arg = (char *)c1xmalloc(arg_len+1);

    memcpy(a->arg, bp, arg_len);

    a->arg[arg_len] = 0;

    bp = ep+1;

  }

  al = new_arglist(largc);

  for (i=0, a=afirst; inext)

    al->argv[i] = a;

  return al;

}

static ArgList * parse_print0(char *bytes, int length)

{

  int largc, i;

  Arg *a, **anext, *afirst;

  ArgList *al;

  char *bp=bytes, *ep, *last=bytes+length;

  anext = &afirst;

  largc = 0;

  while (bp

  {

    size_t arg_len = strlen(bp);

    ep = bp;

    bp += arg_len + 1;

    *anext = a = new_arg();

    a->was_quoted = 1;

    anext = &(a->next);

    largc++;

    a->arg = (char *)c1xmalloc(arg_len+1);

    memcpy(a->arg, ep, arg_len);

    a->arg[arg_len] = 0;

  }

  al = new_arglist(largc);

  for (i=0, a=afirst; inext)

    al->argv[i] = a;

  return al;

}

static int count_args(ArgList *al)

{

  int i, r=0;

  for (i=0; iargc; i++)

  {

    int j;

    if (al->argv[i]->arg_globbed)

    {

      for (j=0; al->argv[i]->arg_globbed[j]; j++);

      r += j;

    }

    else if (al->argv[i]->arg_file)

    {

      r += count_args(al->argv[i]->arg_file);

    }

    else

    {

      r++;

    }

  }

  return r;

}

static char ** fill_args(char **largv, ArgList *al)

{

  int i;

  for (i=0; iargc; i++)

  {

    int j;

    if (al->argv[i]->arg_globbed)

    {

      for (j=0; al->argv[i]->arg_globbed[j]; j++)

      {

        *largv++ = al->argv[i]->arg_globbed[j];

        al->argv[i]->arg_globbed[j] = 0;

      }

    }

    else if (al->argv[i]->arg_file)

    {

      largv = fill_args(largv, al->argv[i]->arg_file);

    }

    else

    {

      *largv++ = al->argv[i]->arg;

      al->argv[i]->arg = 0;

    }

  }

  return largv;

}

static void expand_response_files(ArgList *al)

{

  int i, f;

  for (i=0; iargc; i++)

  {

    if (! al->argv[i]->was_quoted && al->argv[i]->arg[0] == '@')

      if ((f = _open(al->argv[i]->arg+1, O_RDONLY)) >= 0)

      {

	char *bytes;

	int len, st_size;

	st_size = lseek(f, 0L, SEEK_END);

	lseek(f, 0L, SEEK_SET);

        if (st_size < 0)

	  st_size = 0;

        bytes = (char *)c1xmalloc(st_size+1);

        len = _read(f, bytes, st_size);

        if (len < 0)

	  len = 0;

        _close(f);

        /* if the last character is ^Z, remove it */

        if (len > 0 && bytes[len-1] == 0x1a)

          len--;

	/* assume 'find -print0' if the last char is a '\0' */

	if (len > 0 && bytes[len-1] == '\0')

          al->argv[i]->arg_file = parse_print0(bytes, len);

	else

          al->argv[i]->arg_file = parse_bytes(bytes, len, (_crt0_startup_flags & _CRT0_FLAG_KEEP_QUOTES) == 0);

        expand_response_files(al->argv[i]->arg_file);

	free(bytes);

      }

  }

}

static void expand_wildcards(ArgList *al)

{

  int i;

  for (i=0; iargc; i++)

  {

    if (al->argv[i]->arg_file)

      expand_wildcards(al->argv[i]->arg_file);

    else if (!(al->argv[i]->was_quoted))

    {

      al->argv[i]->arg_globbed = __crt0_glob_function(al->argv[i]->arg);

    }

  }

}

static void add_arg(const char* arg, const char* end)

{

	char* res;

	__crt0_argv = realloc(__crt0_argv, 4*(++__crt0_argc));

	res = malloc(end-arg+1);

	if (!__crt0_argv || !res) _exit(1);

	__crt0_argv[__crt0_argc-1] = res;

	while (arg < end)

	{

		if (arg[0] == '"' && arg[1] == '"') ++arg;

		*res++ = *arg++;

	}

	*res = 0;

}

void __crt0_setup_arguments(void)

{

#if 0

// ­¥ ¡ã¤¥¬ áâà ¤ âì 䨣­ñ©...

  ArgList *arglist;

  char *argv0;

  int prepend_argv0 = 1;

  int should_expand_wildcards = 1;

  char *proxy_v = 0;

  argv0="menuet.app";

  /*

  ** Next, scan dos's command line.

  */

  {

    char doscmd[128];

    memcpy(doscmd+1,__menuet__app_param_area,128);

    arglist = parse_bytes(doscmd+1, doscmd[0] & 0x7f,

			  (_crt0_startup_flags & _CRT0_FLAG_KEEP_QUOTES) == 0);

  }

  /*

  **  Now, expand response files

  */

  if (!(_crt0_startup_flags & _CRT0_FLAG_DISALLOW_RESPONSE_FILES))

    expand_response_files(arglist);

  /*

  **  Now, expand wildcards

  */

  if (should_expand_wildcards)

    expand_wildcards(arglist);

  __crt0_argc = prepend_argv0 + count_args(arglist);

  __crt0_argv = (char **)c1xmalloc((__crt0_argc+1) * sizeof(char *));

  if (prepend_argv0)

    __crt0_argv[0] = argv0;

  *fill_args(__crt0_argv+prepend_argv0, arglist) = 0;

#else

// ...  ¯à®áâ® à §¡¥àñ¬ ª®¬ ­¤­ãî áâபã. - diamond

	char* ptr;

	char* cur_arg=NULL;

	int bInQuote=0;

	add_arg(__menuet__app_path_area,

		__menuet__app_path_area + strlen(__menuet__app_path_area));

	for (ptr=__menuet__app_param_area;*ptr && ptr<__menuet__app_param_area+256;ptr++)

	{

		if (*ptr == ' ' || *ptr == '\t')

		{

			if (cur_arg && !bInQuote)

			{

				add_arg(cur_arg,ptr);

				cur_arg = NULL;

			}

			continue;

		}

		if (*ptr == '"')

		{

			if (ptr[1] == '"')

			{if (!cur_arg) cur_arg=ptr;ptr++;}

			else

			{

				if (cur_arg)

				{

					add_arg(cur_arg,ptr);

					if (bInQuote)

					{

						bInQuote = 0;

						cur_arg = NULL;

						continue;

					}

				}

				bInQuote = 1;

				cur_arg = ptr+1;

			}

			continue;

		}

		if (!cur_arg) cur_arg = ptr;

	}

	if (cur_arg) add_arg(cur_arg,ptr);

#endif

}