minix/commands/awk/r.c

/*
 * a small awk clone
 *
 * (C) 1989 Saeko Hirabauashi & Kouichi Hirabayashi
 *
 * Absolutely no warranty. Use this software with your own risk.
 *
 * Permission to use, copy, modify and distribute this software for any
 * purpose and without fee is hereby granted, provided that the above
 * copyright and disclaimer notice.
 *
 * This program was written to fit into 64K+64K memory of the Minix 1.2.
 */


#include <stdio.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#ifdef DOS
#include <process.h>
#endif
#include "awk.h"
#include "regexp.h"

#define MAXFLD	100

extern char **FS, **RS, **OFS, **ORS, **FILENAME;
extern double *NF, *NR;
extern double *FNR;
extern double *ARGC;
extern SYMBOL *argtab[];
extern CELL *getvar();

char *strsave(), *strcpy(), *getsval(), *jStrchr(), *strchr();
double getfval(), atof();
CELL *mkcell(), *mktmp(), *execute(), *patexec();
FILE *efopen();

extern CELL truecell, falsecell;

extern int pateval;

int infileno = 1;
FILE *ifp;
char record[BUFSIZ];
CELL *field[MAXFLD];

char *fs_str;
regexp *fs_pat;

CELL *
Getline(p) NODE *p;
{
  CELL *u;
  char *fnam, *s, str[BUFSIZ];
  int i;
  FILE *fp, *getfp();

  if ((int) p->n_arg[0])	/* read into var */
	s = str;
  else
	s = NULL;
  if ((int) p->n_arg[1]) {	/* file name */
	u = execute(p->n_arg[1]);
	fnam = getsval(u);
	fp = getfp(fnam, (int) p->n_arg[2]);
	c_free(u);
	i = get1rec(s, fp);
  }
  else
	i = Getrec(s);
  if (s == str) {
	u = execute(p->n_arg[0]);
	setsval(u, str);
  }
  return mktmp(NUM, NULL, (double) i);
}

static
get1rec(buf, fp) char *buf; FILE *fp;
{
  register int c;
  register char rs, *s;
  int mflg;

  if (buf == NULL)
	buf = record;
  if ((rs = **RS) == '\0') {	/* multi line record */
	mflg = 1;
	rs = '\n';
  }
  else
	mflg = 0;

  if (feof(fp) || (c = getc(fp)) == EOF)
	return 0;
  for (s = buf; ; ) {
	for ( ; c != rs && c != EOF; c = getc(fp)) {
		if (isKanji(c)) {
			*s++ = c; c = getc(fp);
		}
		*s++ = c;
	}
	if (mflg) {
		if ((c = getc(fp)) == '\n' || c == EOF)
			break;
		*s++ = '\n';
	}
	else
		break;
  }
  *s = '\0';
#if 1
  if (buf == record) {
#else
  if (buf == record && c != EOF) {
#endif
	mkfld(record, *FS, field);
	(*NR)++;
	(*FNR)++;
  }
  return s > buf || c != EOF ? 1 : 0;
}

Getrec(s) char *s;
{
  CELL *u;
  char *file, str[8];

  while (ifp == stdin || infileno < (int)*ARGC) {
	if (ifp == NULL) {
		*FNR = 0.0;
		if (infileno == (int)*ARGC)
			break;
		sprintf(str, "%d", infileno);
		u = getvar(str, argtab);
		file = getsval(u);
		if (strchr(file, '=') != NULL) {
			setvar(file);
			infileno++;
			continue;
		}
		else if (strcmp(file, "") == 0) {
/*
if (infileno == (int)*ARGC - 1)
			ifp = stdin;
*/
			infileno++;
			continue;
		}
		else {
			if (strcmp(file, "-") == 0)
				ifp = stdin;
			else
				ifp = efopen(file, "r");
			*FILENAME = file;
		}
	}
	if (get1rec(s, ifp))
		return 1;
	else {
		if (ifp != stdin)
			fclose(ifp);
		ifp = NULL;
		infileno++;
	}
  }
  ifp = stdin;	/* for further "getline" */
  *FILENAME = "-";
  return 0;	/* EOF */
}

mkfld(rec, sep, fld) char *rec, *sep; CELL *fld[];
{
  char *s, *t;
  char str[BUFSIZ];
  int i, j, n;
  int skip = 0;

  if (strlen(sep) > 1)
	return r_mkfld(rec, sep, fld);

  if (*sep == ' ' || *sep == '\0') {
	sep = " \t\n"; skip++;
  }
  for (i = 1, n = (int) *NF; i <= n; i++) {
	sfree(fld[i]->c_sval);
	sfree(fld[i]);
	fld[i] = NULL;
  }
  for (i = 0, s = rec; ; ) {
	t = str;
	if (skip) {
		while (*s && strchr(" \t\n", *s))
			s++;
		if (*s == '\0')
			break;
	}
	while (*s && !jStrchr(sep, *s)) {
		if (isKanji(*s))
			*t++ = *s++;
		*t++ = *s++;
	}
	*t = '\0';
	if (isnum(str))
		fld[++i] =  mkcell(FLD|STR|NUM, str, atof(str));
	else
		fld[++i] =  mkcell(FLD|STR, str, 0.0);
	if (*s)
		s++;
	else
		break;
  }
  *NF = (double) i;
  return i;
}

static
r_mkfld(rec, sep, fld) char *rec, *sep; CELL *fld[];
{
  char *s, *t;
  char str[BUFSIZ];
  int i, n;
  regexp *mkpat();
  extern int r_start, r_length;

  if (strcmp(*FS, fs_str) != 0) {
	sfree(fs_str); sfree(fs_pat);
	fs_str = strsave(*FS);
	fs_pat = mkpat(fs_str);
  }
  for (i = 1, n = (int) *NF; i <= n; i++) {
	sfree(fld[i]->c_sval);
	sfree(fld[i]);
	fld[i] = NULL;
  }
  for (i = 0, s = rec, t = str; *s; ) {
	if (match(fs_pat, s)) {
		for (n = r_start; --n > 0; )
			*t++ = *s++;
	}
	else {
		while (*s)
			*t++ = *s++;
	}
	*t = '\0';
	t = str;
	fld[++i] = mkcell(FLD|STR, str, 0.0);
	if (*s)
		s += r_length;
  }
  *NF = (double) i;
  return i;
}

mkrec(u) CELL *u;
{
  register char *s, *t;
  register int i, j;

  for (j = (int)*NF, i = 1; i <= j; i++)
	if (field[i] == u)
		break;
  if (i > j) {
	for ( ; i < MAXFLD; i++)
		if (field[i] == u)
			break;
	if (i == MAXFLD)
		error("too many field (%d)", i);
	*NF = (double)i;
  }
  for (t = record, i = 1, j = (int) *NF; i <= j; i++) {
	if (i > 1)
		*t++ = **OFS;
	for (s = getsval(field[i]); *s; )
		*t++ = *s++;
  }
  *t++ = '\0';
}

CELL *
Field(p) NODE *p;
{
  CELL *u;
  int i, j;

  u = execute(p->n_arg[0]);
  i = (int) getfval(u);
  c_free(u);
  j = (int)*NF;
  if (i > j)
	for (++j; j <= i; j++) {
		if (field[j] == NULL)
			field[j] = mkcell(FLD|STR, "", 0.0);
	}
  return field[i];
}

CELL *
P1stat(p) NODE *p;
{
  CELL *u;
  double x;

  pateval++;
  u = execute(p->n_arg[0]);
  pateval = 0;
  x = getfval(u);
  c_free(u);
  if (x != 0.0)
	u = execute(p->n_arg[1]);
  else
	u = &truecell;
  return u;
}

CELL *
P2stat(p) NODE *p;
{
  static stat = 0;
  CELL *u, *v;
  double x;

  switch (stat) {
  case 0:
	pateval++;
	u = execute(p->n_arg[0]);
	pateval = 0;
	x = getfval(u);
	c_free(u);
	if (x == 0.0) {
		u = &truecell; break;
	}
	else
		stat++;
	/* fall through */
  case 1:
	u = execute(p->n_arg[2]);
	c_free(u);
	pateval++;
	u = execute(p->n_arg[1]);
	pateval = 0;
	x = getfval(u);
	if (x != 0.0)
		stat = 0;
	break;
  default:
	u = &truecell;
	break;
  }
  return u;
}

CELL *
Print0()
{
/*
  int i, j;
  char *s, str[BUFSIZ];

  for (*str = '\0', i = 1, j = (int) *NF; i <= j; i++) {
	if (i > 1)
		strcat(str, *OFS);
	s = getsval(field[i]);
	strcat(str, s);
  }
  strcat(str, *ORS);
  fputs(str, stdout);
*/
  fprintf(stdout, "%s%s", record, *ORS);
  return &truecell;
}

char *
format(t, p) char *t; NODE *p;
{
  CELL *u, *v;
  char *r, *s, *s0, fmt[BUFSIZ];
  double x;
  int i;

  u = execute(p->n_arg[2]);
  s = s0 = getsval(u);
/*
printf("fmt(%s)\n", s);
*/
  for (i = 3; *s; s++) {
	if (isKanji(*s)) {
		*t++ = *s++; *t++ = *s; continue;
	}
	if (*s != '%') {
		*t++ = *s; continue;
	}
	else if (*(s + 1) == '%') {
		*t++ = *s++; continue;
	}
	for (r = fmt, *r++ = *s++; *r++ = *s; s++) {
		if (strchr("%cdefgosux", *s))
			break;
	}
	*r = '\0';
	if (p->n_arg[i] == NULL)
		error("not enough args in printf(%s)", s0);
	v = execute(p->n_arg[i++]);
	if (*s == 's')
		r = getsval(v);
	else
		x = getfval(v);
/*
printf("val(%d)(%s)\n", v->c_type, v->c_sval);
*/
	switch (*s) {
	case 'c':
		sprintf(t, fmt, (int) x);
		break;
	case 'd':
		if (*(s - 1) != 'l') {
			*--r = 'l'; *++r = 'd'; *++r = '\0';
		}
		sprintf(t, fmt, (long) x);
		break;
	case 'e': case 'f': case 'g':
		sprintf(t, fmt, x);
		break;
	case 'o': case 'u': case 'x':
		if (*(s - 1) == 'l')
			sprintf(t, fmt, (long) x);
		else
			sprintf(t, fmt, (int) x);
		break;
	case 's':
		/*r = getsval(v);*/
		sprintf(t, fmt, r);
		break;
	default:
		strcpy(t, fmt);
		break;
	}
	c_free(v);
	t += strlen(t);
  }
  c_free(u);
  *t = '\0';
}

#define MAXFILE	10
struct {
  char *f_name;	/* file name */
  FILE *f_fp;
  int f_type;
} filetab[MAXFILE];

FILE *
getfp(file, type) char *file;
{
  register int i;
  register char *name, *mode;
  char *awktmp();
  FILE *fp, *efopen(), *epopen();

  for (i = 0; i < MAXFILE; i++)
	if (filetab[i].f_name && strcmp(filetab[i].f_name, file) == 0)
		return filetab[i].f_fp;
  for (i = 0; i < MAXFILE; i++)
	if (!filetab[i].f_fp)
		break;
  if (i == MAXFILE)
	error("too many files to open");
  name = file;
  switch (type) {
  case R_OUT:	mode = "w"; break;
  case R_APD:	mode = "a"; break;
  case R_POUT:
#ifdef DOS
	name = awktmp(i); mode = "w";	/* MS-DOS */
#else
	fp = epopen(file, "w");
	goto g1;
#endif
	break;
  case R_IN:	mode = "r"; break;
  case R_PIN:
#ifdef DOS
	{
		int savefd, fd, result;

		name = awktmp(i);
		if ((fd = open(name,
		O_WRONLY|O_TEXT|O_CREAT|O_TRUNC,S_IREAD|S_IWRITE)) == -1)
			error("can't open %s", name);
		savefd = dup(1); dup2(fd, 1); close(fd);
		if ((result =
			system(file)) == -1)
			error("can't exec %s", file);
		dup2(savefd, 1); close(savefd); close(fd);
		mode = "r";
	}
#else
	fp = epopen(file,"r");
	goto g1;
#endif
	break;
  }
  fp = efopen(name, mode);
g1:
  filetab[i].f_name = strsave(file);
  filetab[i].f_type = type;
  filetab[i].f_fp = fp;
  return fp;
}

closeall()
{
  register int i;

  for (i = 0; i < MAXFILE; i++)
	close1(i);
}

CELL *
Close(s) char *s;
{
  register int i;

  for (i = 0; i < MAXFILE; i++)
	if (strcmp(s, filetab[i].f_name) == 0) {
		close1(i);
		break;
	}
  i = (i == MAXFILE) ? 0 : 1;
  return mktmp(NUM, NULL, (double) i);
}

static
close1(i)
{
  int fd, result, savefd;
  char *awktmp();

  if (filetab[i].f_fp == NULL)
	return;
  switch (filetab[i].f_type) {
  case R_PIN:
#ifdef DOS
	fclose(filetab[i].f_fp);
	unlink(awktmp(i));
#else
	pclose(filetab[i].f_fp);
#endif
	break;
  case R_IN: case R_OUT: case R_APD:
	fclose(filetab[i].f_fp);
	break;
  case R_POUT:
#ifdef DOS
	fclose(filetab[i].f_fp);
	if ((fd = open(awktmp(i), O_RDONLY)) == NULL)
		error("can't open %s", awktmp(i));
	savefd = dup(0);
	dup2(fd, 0);
	close(fd);
	if ((result =
		system(filetab[i].f_name)) == -1)
/*
	spawnl(P_WAIT, "/usr/bin/sh", "sh", "-c", filetab[i].f_name, (char *) 0)) == -1)
		fprintf(stderr, "can't spawn /bin/sh\n");
*/
		error("can't exec %s", filetab[i].f_name);
	dup2(savefd, 0);
	close(savefd);
	unlink(awktmp(i));
#else
	pclose(filetab[i].f_fp);
#endif
	break;
  }
  sfree(filetab[i].f_name);
  filetab[i].f_type = 0;
  filetab[i].f_name = NULL;
  filetab[i].f_fp = NULL;
}

#ifndef DOS
FILE *
epopen(file, mod) char *file, *mod;
{
  FILE *fp, *popen();

  if ((fp = popen(file, mod)) == NULL)
	error("can't poen %s", file);
  return fp;
}
#endif

static char *
awktmp(i)
{
  static char str[16];

  sprintf(str, "awk000%02d.tmp", i);
  return str;
}

Index(s, t) char *s, *t;
{
  register char *u, *v;
  register int i;

  for (i = 1; *s; s++, i++) {
	for (u = s, v = t; *v; u++, v++) {
		if (isKanji(*v)) {
			if (*u != *v)
				break;
			u++; v++;
		}
		if (*u != *v)
			break;
	}
	if (*v == '\0')
		return i;
	if (isKanji(*s))
		s++;
  }
  return 0;
}