e.c

操作系统源代码

  default:
	fprintf(stderr, "unknown string function");
	break;
  }
  c_free(u);
  return r;
}

static regexp *
getpat(r) CELL *r;
{
  regexp *pat, *mkpat();

  if (r->c_type & PAT)
	pat = (regexp *) r->c_sval;
  else {
	if (r_str && strcmp(r_str, r->c_sval) == 0)
		pat = r_pat;
	else {
		sfree(r_str); sfree(r_pat);
		r_str = strsave(getsval(r));
		pat = r_pat = mkpat(r_str);
	}
  }
  return pat;
}

static CELL *
Subst(p) NODE *p;
{
  CELL *u, *v, *w;
  char *s, *t, *r, str[BUFSIZ], *strcpy();
  int i, n;

  n = (int) p->n_arg[1];
  if (n > 1) {
	u = execute(p->n_arg[3]);	/* substitute string */
	s = getsval(u);
	v = execute(p->n_arg[2]);	/* expr */
	if (n > 2) {
		w = execute(p->n_arg[4]);
		t = getsval(w);
		r = str;
	}
	else {
		t = r = record;
		w = NULL;
	}
	i = (int) p->n_arg[0] == RGSUB ? 0 : 1;
	if (v->c_type & (PAT|STR))
		i = Sub(r, v->c_sval, (v->c_type & STR), s, t, i);
	else
		error("[g]sub(PAT, .. ) must be /../ or string (%d)",
			w->c_type);
	if (n > 2) {
		if (w->c_type & REC) {
			strcpy(record, str);
			mkfld(record, *FS, field);
		}
		else
			setsval(w, str);
	}
	else
		mkfld(record, *FS, field);
	c_free(u);
	c_free(v);
	c_free(w);
  }
  else
	i = 0;
  return mktmp(NUM, NULL, (double) i);
}

static CELL *
Cond(p) NODE *p;
{
  CELL *u, *v;
  double x, y;
  int op, i, j;
  char *s;
  int save = pateval;

  op = (int) p->n_arg[0];
  u = execute(p->n_arg[1]);
  x = getfval(u);
/*
printf("Cond(%d)(%s)\n", u->c_type, u->c_sval);
*/
  if (op == AND || op == OR || op == NOT) {
	if (u->c_type & NUM)
		i = (x != 0.0);
	else {
		s = getsval(u);
		i = (s != (char *)NULL) && (*s != '\0');
	}
  }
  if (op == AND && !i) {
	c_free(u);
	return &falsecell;
  }
  if (op == OR && i) {
	c_free(u);
	return &truecell;
  }
  if (op == NOT)
	i = i == 0 ? 1 : 0;
  else {
	if (op == MATCH || op == NOMATCH)
		pateval = 0;
	v = execute(p->n_arg[2]);
	y = getfval(v);
	if (op == AND || op == OR || op == BINAND || op == BINOR) {
		if (v->c_type & NUM)
			j = (y != 0.0);
		else {
			s = getsval(v);
			j = (s != (char *)NULL) && (*s != '\0');
		}
		switch (op) {
		case AND:	i = i && j; break;
		case OR:	i = i || j; break;
		case BINAND:	i = i & j; break;
		case BINOR:	i = i | j; break;
		}
	}
	else if (op == MATCH || op == NOMATCH) {
		char *s;
		regexp *pat, *getpat();

		s = getsval(u);
		pat = getpat(v);
		i = match(pat, s) == 0 ? 0 : 1;
		if (op == NOMATCH)
			i = i == 0 ? 1 : 0;
	}
	else {	/* relative operator */
/*
printf("Cond(%d)(%d)(%s)(%s)\n", u->c_type, v->c_type, u->c_sval, v->c_sval);
*/
		if ((u->c_type & NUM) && (v->c_type & NUM))
			i = x < y ? -1 : (x > y ? 1 : 0);
		else
			i = strcmp(getsval(u), getsval(v));
/*
printf("Cond(%d)(%d)(%g)(%g)(%d)\n", u->c_type, v->c_type, x, y, i);
*/

		switch (op) {
		case LT:	i = i < 0 ? 1 : 0; break;
		case LE:	i = i <= 0 ? 1 : 0; break;
		case EQ:	i = i == 0 ? 1 : 0; break;
		case NE:	i = i != 0 ? 1 : 0; break;
		case GT:	i = i > 0 ? 1 : 0; break;
		case GE:	i = i >= 0 ? 1 : 0; break;
		default:
			fprintf(stderr, "unknown relative operator (%d)\n", op);
			break;
		}
	}
	c_free(v);
  }
  c_free(u);
  pateval = save;
  return mktmp(NUM, NULL, (double) i);
}

static CELL *
If(p) NODE *p;
{
  CELL *u;
  int i;
  char *s;

  u = execute(p->n_arg[0]);
  if (u->c_type & NUM)
	i = (getfval(u) != 0.0);
  else {
	s = getsval(u);
	i = (s != (char *)NULL) && (*s != '\0');
  }
  c_free(u);
  if (i)
	u = execute(p->n_arg[1]);
  else if (p->n_arg[2])
	u = execute(p->n_arg[2]);
  else
	u = &truecell;
  return u;
}

static CELL *
While(p) NODE *p;
{
  CELL *u;
  double x;

  for (;;) {
	u = execute(p->n_arg[0]);
	x = getfval(u);
	if (x == 0.0)
		break;
	c_free(u);
	u = execute(p->n_arg[1]);
	switch (u->c_type) {
	case BRK:
		goto rtn;
	case NXT: case EXT: case RTN:
		return u;
	}
	c_free(u);
  }
rtn:
  c_free(u);
  return &truecell;
}

static CELL *
Do(p) NODE *p;
{
  CELL *u;
  double x;

  for (;;) {
	u = execute(p->n_arg[0]);
	switch (u->c_type) {
	case BRK:
		goto rtn;
	case NXT: case EXT: case RTN:
		return u;
	}
	c_free(u);
	u = execute(p->n_arg[1]);
	if(getfval(u) == 0.0)
		break;
	c_free(u);
  }
rtn:
  c_free(u);
  return &truecell;
}

static CELL *
For(p) NODE *p;
{
  CELL *u;
  double x;

  if (p->n_arg[0] != NULL) {
	u = execute(p->n_arg[0]);
	c_free(u);
  }
  for (;;) {
	if (p->n_arg[1] != NULL) {
		u = execute(p->n_arg[1]);
		x = getfval(u);
		c_free(u);
		if (x == 0.0)
			break;
	}
	u = execute(p->n_arg[3]);
	switch (u->c_type) {
	case BRK:
		c_free(u);
		goto rtn;
	case NXT: case EXT: case RTN:
		return u;
	}
	if (p->n_arg[2] != NULL) {
		u = execute(p->n_arg[2]);
		c_free(u);
	}
  }
rtn:
  return &truecell;
}

static CELL *
Jump(p) NODE *p;
{
  CELL *u;
  int i;

  switch ((int) p->n_arg[0]) {
  case BREAK:	u = &breakcell; break;
  case CONTIN:	u = &contcell;  break;
  case EXIT:
	if ((int) p->n_arg[1]) {
		u = execute(p->n_arg[1]);
		i = (int) getfval(u);
	}
	else
		i = 0;
	closeall();
	exit(i);
  case RETURN:
	Return(p);
	u = &retcell;
	break;
  case NEXT:	u = &nextcell; break;
  }
  return u;
}

static
Return(p) NODE *p;
{
  CELL *u;
  int i;
  char *s, str[BUFSIZ];

  c_free(retval);
  if (p->n_arg[1] != NULL) {
	if (p->n_arg[2] == NULL) {
/*
if (0) {
*/
		u = execute(p->n_arg[1]);
		if (u->c_type == UDF)
			retval = mktmp(STR, "", 0.0);
		else
			retval = mktmp(u->c_type, u->c_sval, u->c_fval);
		c_free(u);
	}
	else {
		for (i = 1; p->n_arg[i] != NULL; i++) {
			if (i == 1)
				*str = '\0';
			else
				strcat(str, *OFS);
			u = execute(p->n_arg[i]);
			s = getsval(u);
			strcat(str, s);
			c_free(u);
		}
/*
printf("Ret(%s)(%d)\n", str, isnum(str));
*/
		if (isnum(str))
			retval = mktmp(STR|NUM, str, atof(str));
		else
			retval = mktmp(STR, str, 0.0);
	}
  }
  else
	retval = &truecell;
}

#define MAXFRAME	100
CELL **frame[MAXFRAME];
static int framep;

static CELL *
Arg(p) NODE *p;
{
  CELL *u;
  int i;

  u = (CELL *)p->n_arg[0];
  return _Arg((int)u->c_fval);
}

CELL *
_Arg(i)
{
/*
printf("Arg(%d)\n", i);
*/
  return frame[framep - 1][i];
}

static CELL *
Call(p) NODE *p;
{
  CELL *u, *v, *r, **arg;
  NODE *q;
  int i, j, k, n;
  char *emalloc();

  if (framep >= MAXFRAME - 2)
	error("stack frame overflow", (char *)0);
  retval = &truecell;
  r = (CELL *) p->n_arg[0];
  if (r->c_type != FUN)
	synerr("called function is not declared", (char *)0);
  n = (int) r->c_fval;	/* # of params */
  if (n > 0) {
	arg = (CELL **) emalloc(sizeof(u) * n);
	for (i = 2, j = 0, k = (int) p->n_arg[1]; j < k; i++) {
		u = execute(p->n_arg[i]);
/*
printf("pass, j(%d)typ(%d)\n", j, u->c_type);
*/
		if (u->c_type & ARR)
			v = u;	/* pass by reference */
		else {	/* pass by value */
			v = mkcell(UDF, u->c_sval, u->c_fval);
			if (u->c_type != UDF) {
#if 0
				v->c_type = u->c_type;
				if (v->c_type & (NUM|STR))
					v->c_type |= VAR;
				v->c_type &= ~TMP;	/* dont't free */
#else
				v->c_type |= (u->c_type & (NUM|STR))|VAR;
				/*v->c_type &= ~TMP;*/
#endif
				/* Don't free original */
			}
/*
printf("pass1, j(%d)typ(%d)\n", j, v->c_type);
*/
		}
		arg[j++] = v;
	}
	for ( ; j < n; )	/* local var */
		arg[j++] = mkcell(UDF, NULL, 0.0);
  }
  else
	arg = NULL;

  frame[framep] = arg;
  framep++;

  r = execute(r->c_sval);
  c_free(r);
  framep--;
  if (n > 0) {
	for (j = n - 1 ; j > k; j--) {	/* local var */
		u = arg[j];
		if (u->c_type & ARR)
			a_free(u);
		else
			c_free(u);
	}
	for ( ; j >= 0; j--) {
		u = arg[j];
		if (!(u->c_type & ARR)) {
/*			c_free(u);*/
			sfree(u->c_sval);
			sfree(u);
		}
		else {
			v = execute(p->n_arg[j + 2]);
			if (v->c_type == UDF) {	/* copy back */
/*
printf("copy_back_UDF(%d)(%d)\n", j, u->c_type);
*/
				v->c_type = u->c_type;
				sfree(v->c_sval);
				v->c_sval = u->c_sval;
				v->c_fval = u->c_fval;
				sfree(u);
			}
		}
	}
  }
  sfree(arg);
/*  return retval;*/
  u = mktmp(retval->c_type, retval->c_sval, retval->c_fval);
  return u;
}

CELL *Nulproc()
{
  return &truecell;
}

CELL *
Usrfun(p) NODE *p;
{
  CELL *u;

  u = execute(p);
  return u;
}