Ejemplo n.º 1
0
/*
 * listshuffle()
 */
LIST *listshuffle(LIST * head)
{
    LIST **array, *newhead = NULL;
    int n, i = 0, val;
    struct timeval tv;

    gettimeofday(&tv, NULL);
    srandom(tv.tv_usec);

    n = listcnt(head);
    array = list2array(head);

    while (i < n) {
	val = random() % n;

	if (array[val]) {
	    newhead = listprep(newhead, array[val]);
	    array[val] = NULL;
	    i++;
	}
    }

    G_free(array);

    return newhead;
}
Ejemplo n.º 2
0
Archivo: glob.c Proyecto: muennich/rc3
static List *sort(List *s) {
    size_t nel = listnel(s);
    if (nel > 1) {
        char **a;
        List *t;
        qsort(a = list2array(s, FALSE), nel, sizeof(char *), starstrcmp);
        for (t = s; t != NULL; t = t->n)
            t->w = *a++;
    }
    return s;
}
Ejemplo n.º 3
0
int bucketsort(void **a, size_t n, keyaccessor_t key, indexer_t idx,
	       comparator_t cmp)
{
    _cons_t *lists = (_cons_t *) malloc(n * sizeof(_cons_t));
    if (!lists) {
	perror("malloc failed!");
	return -1;
    }
    #if BUCKETSORT_PROFILE
    when = dtime(); array2list(a, lists, n); ptime();
    when = dtime(); list_t l = bucketsort_l(lists, key, idx, cmp); ptime();
    when = dtime(); list2array(l, a, n); ptime();
    #else
    array2list(a, lists, n);
    list_t l = bucketsort_l(lists, key, idx, cmp);
    list2array(l, a, n);
    #endif
    free(lists);
    return 0;
}
Ejemplo n.º 4
0
int bucketsort(void **a, size_t n, keyaccessor_t key, indexer_t idx,
	       comparator_t cmp)
{
    _cons_t *lists = (_cons_t *) malloc(n * sizeof(_cons_t));
    if (!lists) {
	perror("malloc failed!");
	return -1;
    }
    array2list(a, lists, n);
    list_t l = bucketsort_l(lists, key, idx, cmp);
    list2array(l, a, n);
    free(lists);
    return 0;
}
Ejemplo n.º 5
0
static void
set_instance_fields(struct xcl_context *xc, struct ML *mlp)
{
  const char *lastw = "";
  int i;
  static char formbuf[128], normbuf[128];
  List *parts = list_create(LIST_SINGLE);

  *formbuf = *normbuf = '\0';
  for (i = 0; i < mlp->matches_used; ++i)
    {
      /* Should we be discriminating about which match
	 of matches[i].matches[] we are using for this? */
      struct f2 *lform = mlp->matches[i].matching_f2s[0];
      struct f2 *clone = mb_new(xc->sigs->mb_f2s);
      /* This is a shallow clone; we only need it so we can
	 set the flags locally */
      *clone = *lform;
      list_add(parts, lform);
      if (strcmp(lastw,mlp->matches[i].lp->ref))
	{
	  if (*formbuf)
	    strcat(formbuf, " ");
	  strcat(formbuf,(char*)lform->form);
	}
      else
	BIT_SET(lform->flags,F2_FLAGS_SAME_REF);
      lastw = mlp->matches[i].lp->ref;
      if (lform->norm)
	{
	  if (*normbuf)
	    strcat(normbuf, " ");
	  strcat(normbuf,(char*)lform->norm);
	}
    }
  mlp->matches[0].psu_form->form = (unsigned char*)formbuf;
  mlp->matches[0].psu_form->norm = (unsigned char*)normbuf;
  mlp->matches[0].psu_form->file = (unsigned char*)mlp->matches[0].lp->f->file;
  mlp->matches[0].psu_form->lnum = mlp->matches[0].lp->f->lnum;
  mlp->matches[0].psu_form->parts = (struct f2**)list2array(parts);
  list_free(parts, NULL);
}
Ejemplo n.º 6
0
void getpars(char *procparfile,struct data *d)
{

  /* Null the data structure */
  nulldata(d);

  /* Copy procpar filename */
  if ((d->procpar = (char *)malloc((strlen(procparfile)+1)*sizeof(char))) == NULL) nomem(__FILE__,__FUNCTION__,__LINE__);
  strcpy(d->procpar,procparfile);

  /* Get the parameters, some attributes, and their values */
  getprocparpars(procparfile,&d->p);

  /* Set and fill the 'pars' array structure.
     We convert array to an array of pars in the 'pars' array structure.
     We also figure how often each par cycles as the expt is run */
  setarray(&d->p,&d->a);

  /* Convert sviblist to an array of pars in the 'pars' sviblist structure */
  list2array("sviblist",&d->p,&d->s);

}
Ejemplo n.º 7
0
void setarray(struct pars *p,struct pars *a)
{
  int i,j,k,n;
  int joint;
  double *cycles;
  char str[MAXPATHLEN];

  if (!list2array("array",p,a)) return;

  /* Take a copy of the array string */
  strcpy(str,*sval("array",p));

  /* Fill with parameter names from the array string */
  /* 'array' is a string, so we will use member 'd' to hold a 'joint' index
     with which we can track parameters that are jointly arrayed */
  /* Allocate memory for a->d */
  if ((a->d = (double **)malloc(sizeof(double *))) == NULL) nomem(__FILE__,__FUNCTION__,__LINE__);
  if ((a->d[0] = (double *)malloc(*a->nvals*sizeof(double))) == NULL) nomem(__FILE__,__FUNCTION__,__LINE__);
  /* Initialise a->d */
  for (i=0;i<*a->nvals;i++) a->d[0][i]=0;
  joint=0; j=0; k=0;
  for (i=0;i<strlen(str);i++) {
    if (str[i] == '(') {
      i++; a->d[0][j]=1; joint=1;
    }
    if (str[i] == ')') {
      i++; joint=0;
    }
    if (str[i] == ',') {
      if (joint) {
        a->d[0][j]++;
        a->d[0][j+1]=a->d[0][j]; /* for a ',' j+1 will always exist */
      }
      a->s[0][j++][k]=0; /* NULL terminate */
      k=0;
    }
    else
      a->s[0][j][k++]=str[i];
  }
  a->s[0][j][k]=0; /* NULL terminate */

  /* As such:
     The 'joint' index is 0 for parameters that are not jointly arrayed.
     Arrayed parameters generate indices as follows:

       array                     'joint' index
                     parameter   a  b  c  d  e
     (a,b),c,d,e   :             2  2  0  0  0
     a,(b,c),d,e   :             0  2  2  0  0
     (a,b,c),d,e   :             2  3  3  0  0
     a,(b,c,d),e   :             0  2  3  3  0
     a,(b,c,d,e)   :             0  2  3  4  4
     a,(b,c),(d,e) :             0  2  2  2  2
     (a,b,c,d,e)   :             2  3  4  5  5

     Starting from the last parameter (which cycles the quickest) we can
     now easily figure how many parameters are jointly arrayed
  */

  /* Convert the 'joint' index to 'cycles' which describes the number of
     volumes over which the parameter cycles */
  /* Allocate for a->nvals 'cycles' */
  if ((cycles = (double *)malloc(*a->nvals*sizeof(double))) == NULL) nomem(__FILE__,__FUNCTION__,__LINE__);

  /* Initialise cycles and joint for the last parameter */
  cycles[*a->nvals-1]=1;
  if (a->d[0][*a->nvals-1] > 0) joint=1;
  else joint=0;

  for (i=*a->nvals-2;i>=0;i--) {
    if (joint) {
      n=a->d[0][i+1]-1;
      for (j=0;j<n;j++) { /* was for (j=0;j<a->d[0][i+1]-1;j++) { */
        cycles[i]=cycles[i+1];
        i--;
      }
      i++; joint=0;
    } else {
      cycles[i]=cycles[i+1]*nvals(a->s[0][i+1],p);
      if (a->d[0][i] > 0) joint=1;
    }
  }

  /* Copy cycles to a->d */
  for (i=0;i<*a->nvals;i++) a->d[0][i]=cycles[i];

#ifdef DEBUG
  fprintf(stdout,"\n%s: %s()\n",__FILE__,__FUNCTION__);
  printarray(a,*sval("array",p));
#endif

}
Ejemplo n.º 8
0
extern void exec(List *s, bool parent) {
	char **av, **ev = NULL;
	int pid, stat;
	builtin_t *b;
	char *path = NULL;
	bool didfork, returning, saw_exec, saw_builtin;
	av = list2array(s, dashex);
	saw_builtin = saw_exec = FALSE;
	do {
		if (*av == NULL	|| isabsolute(*av))
			b = NULL;
		else if (!saw_builtin && fnlookup(*av) != NULL)
			b = funcall;
		else
			b = isbuiltin(*av);

		/*
		   a builtin applies only to the immmediately following
		   command, e.g., builtin exec echo hi
		*/
		saw_builtin = FALSE;

		if (b == b_exec) {
			av++;
			saw_exec = TRUE;
			parent = FALSE;
		} else if (b == b_builtin) {
			av++;
			saw_builtin = TRUE;
		}
	} while (b == b_exec || b == b_builtin);
	if (*av == NULL && saw_exec) { /* do redirs and return on a null exec */
		doredirs();
		return;
	}
	/* force an exit on exec with any rc_error, but not for null commands as above */
	if (saw_exec)
		rc_pid = -1;
	if (b == NULL) {
		path = which(*av, TRUE);
		if (path == NULL && *av != NULL) { /* perform null commands for redirections */
			set(FALSE);
			redirq = NULL;
			if (parent)
				return;
			rc_exit(1);
		}
		ev = makeenv(); /* environment only needs to be built for execve() */
	}
	/*
	   If parent & the redirq is nonnull, builtin or not it has to fork.
	   If the fifoq is nonnull, then it must be emptied at the end so we
	   must fork no matter what.
	 */
	if ((parent && (b == NULL || redirq != NULL)) || outstanding_cmdarg()) {
		pid = rc_fork();
		didfork = TRUE;
	} else {
		pid = 0;
		didfork = FALSE;
	}
	returning = (!didfork && parent);
	switch (pid) {
	case -1:
		uerror("fork");
		rc_error(NULL);
		/* NOTREACHED */
	case 0:
		if (!returning)
			setsigdefaults(FALSE);
		pop_cmdarg(FALSE);
		doredirs();

		/* null commands performed for redirections */
		if (*av == NULL || b != NULL) {
			if (b != NULL)
				(*b)(av);
			if (returning)
				return;
			rc_exit(getstatus());
		}
		execve(path, (char * const *) av, (char * const *) ev);
		uerror(*av);
		rc_exit(1);
		/* NOTREACHED */
	default:
		redirq = NULL;
		rc_wait4(pid, &stat, TRUE);
		setstatus(-1, stat);
		if ((stat & 0xff) == 0)
			nl_on_intr = FALSE;
		SIGCHK;
		nl_on_intr = TRUE;
		pop_cmdarg(TRUE);
	}
}