Subversion Repositories planix.SVN

/* Yacc productions for "expr" command: */

%token OR AND ADD SUBT MULT DIV REM EQ GT GEQ LT LEQ NEQ

%token A_STRING SUBSTR LENGTH INDEX NOARG MATCH

/* operators listed below in increasing precedence: */

%left OR

%left AND

%left EQ LT GT GEQ LEQ NEQ

%left ADD SUBT

%left MULT DIV REM

%left MCH

%left MATCH

%left SUBSTR

%left LENGTH INDEX

%{

#define YYSTYPE charp

typedef char *charp;

%}

%%

/* a single `expression' is evaluated and printed: */

expression:	expr NOARG = {

			prt(1, $1);

			exit((!strcmp($1,"0")||!strcmp($1,"\0"))? 1: 0);

			}

	;

expr:	'(' expr ')' = { $$ = $2; }

	| expr OR expr   = { $$ = conj(OR, $1, $3); }

	| expr AND expr   = { $$ = conj(AND, $1, $3); }

	| expr EQ expr   = { $$ = rel(EQ, $1, $3); }

	| expr GT expr   = { $$ = rel(GT, $1, $3); }

	| expr GEQ expr   = { $$ = rel(GEQ, $1, $3); }

	| expr LT expr   = { $$ = rel(LT, $1, $3); }

	| expr LEQ expr   = { $$ = rel(LEQ, $1, $3); }

	| expr NEQ expr   = { $$ = rel(NEQ, $1, $3); }

	| expr ADD expr   = { $$ = arith(ADD, $1, $3); }

	| expr SUBT expr   = { $$ = arith(SUBT, $1, $3); }

	| expr MULT expr   = { $$ = arith(MULT, $1, $3); }

	| expr DIV expr   = { $$ = arith(DIV, $1, $3); }

	| expr REM expr   = { $$ = arith(REM, $1, $3); }

	| expr MCH expr	 = { $$ = match($1, $3); }

	| MATCH expr expr = { $$ = match($2, $3); }

	| SUBSTR expr expr expr = { $$ = substr($2, $3, $4); }

	| LENGTH expr       = { $$ = length($2); }

	| INDEX expr expr = { $$ = index($2, $3); }

	| A_STRING

	;

%%

/*	expression command */

#include <stdio.h>

/* get rid of yacc debug printf's */

#define printf

#define ESIZE	512

#define error(c)	errxx(c)

#define EQL(x,y) !strcmp(x,y)

long atol();

char *ltoa();

char	**Av;

int	Ac;

int	Argi;

char Mstring[1][128];

char *malloc();

extern int nbra;

int yyparse(void);

main(argc, argv) char **argv; {

	Ac = argc;

	Argi = 1;

	Av = argv;

	yyparse();

}

char *operator[] = { "|", "&", "+", "-", "*", "/", "%", ":",

	"=", "==", "<", "<=", ">", ">=", "!=",

	"match", "substr", "length", "index", "\0" };

int op[] = { OR, AND, ADD,  SUBT, MULT, DIV, REM, MCH,

	EQ, EQ, LT, LEQ, GT, GEQ, NEQ,

	MATCH, SUBSTR, LENGTH, INDEX };

yylex() {

	register char *p;

	register i;

	if(Argi >= Ac) return NOARG;

	p = Av[Argi++];

	if(*p == '(' || *p == ')')

		return (int)*p;

	for(i = 0; *operator[i]; ++i)

		if(EQL(operator[i], p))

			return op[i];

	yylval = p;

	return A_STRING;

}

char *rel(op, r1, r2) register char *r1, *r2; {

	register i;

	if(ematch(r1, "-\\{0,1\\}[0-9]*$") && ematch(r2, "-\\{0,1\\}[0-9]*$"))

		i = atol(r1) - atol(r2);

	else

		i = strcmp(r1, r2);

	switch(op) {

	case EQ: i = i==0; break;

	case GT: i = i>0; break;

	case GEQ: i = i>=0; break;

	case LT: i = i<0; break;

	case LEQ: i = i<=0; break;

	case NEQ: i = i!=0; break;

	}

	return i? "1": "0";

}

char *arith(op, r1, r2) char *r1, *r2; {

	long i1, i2;

	register char *rv;

	if(!(ematch(r1, "-\\{0,1\\}[0-9]*$") && ematch(r2, "-\\{0,1\\}[0-9]*$")))

		yyerror("non-numeric argument");

	i1 = atol(r1);

	i2 = atol(r2);

	switch(op) {

	case ADD: i1 = i1 + i2; break;

	case SUBT: i1 = i1 - i2; break;

	case MULT: i1 = i1 * i2; break;

	case DIV: i1 = i1 / i2; break;

	case REM: i1 = i1 % i2; break;

	}

	rv = malloc(16);

	strcpy(rv, ltoa(i1));

	return rv;

}

char *conj(op, r1, r2) char *r1, *r2; {

	register char *rv;

	switch(op) {

	case OR:

		if(EQL(r1, "0")

		|| EQL(r1, ""))

			if(EQL(r2, "0")

			|| EQL(r2, ""))

				rv = "0";

			else

				rv = r2;

		else

			rv = r1;

		break;

	case AND:

		if(EQL(r1, "0")

		|| EQL(r1, ""))

			rv = "0";

		else if(EQL(r2, "0")

		|| EQL(r2, ""))

			rv = "0";

		else

			rv = r1;

		break;

	}

	return rv;

}

char *substr(v, s, w) char *v, *s, *w; {

register si, wi;

register char *res;

	si = atol(s);

	wi = atol(w);

	while(--si) if(*v) ++v;

	res = v;

	while(wi--) if(*v) ++v;

	*v = '\0';

	return res;

}

char *length(s) register char *s; {

	register i = 0;

	register char *rv;

	while(*s++) ++i;

	rv = malloc(8);

	strcpy(rv, ltoa((long)i));

	return rv;

}

char *index(s, t) char *s, *t; {

	register i, j;

	register char *rv;

	for(i = 0; s[i] ; ++i)

		for(j = 0; t[j] ; ++j)

			if(s[i]==t[j]) {

				strcpy(rv=malloc(8), ltoa((long)++i));

				return rv;

			}

	return "0";

}

char *match(s, p)

{

	register char *rv;

	strcpy(rv=malloc(8), ltoa((long)ematch(s, p)));

	if(nbra) {

		rv = malloc(strlen(Mstring[0])+1);

		strcpy(rv, Mstring[0]);

	}

	return rv;

}

#define INIT	register char *sp = instring;

#define GETC()		(*sp++)

#define PEEKC()		(*sp)

#define UNGETC(c)	(--sp)

#define RETURN(c)	return

#define ERROR(c)	errxx(c)

ematch(s, p)

char *s;

register char *p;

{

	static char expbuf[ESIZE];

	char *compile();

	register num;

	extern char *braslist[], *braelist[], *loc2;

	compile(p, expbuf, &expbuf[ESIZE], 0);

	if(nbra > 1)

		yyerror("Too many '\\('s");

	if(advance(s, expbuf)) {

		if(nbra == 1) {

			p = braslist[0];

			num = braelist[0] - p;

			strncpy(Mstring[0], p, num);

			Mstring[0][num] = '\0';

		}

		return(loc2-s);

	}

	return(0);

}

errxx(c)

{

	yyerror("RE error");

}

#include  "regexp.h"

yyerror(s)

{

	write(2, "expr: ", 6);

	prt(2, s);

	exit(2);

}

prt(fd, s)

char *s;

{

	write(fd, s, strlen(s));

	write(fd, "\n", 1);

}

char *ltoa(l)

long l;

{

	static char str[20];

	register char *sp = &str[18];

	register i;

	register neg = 0;

	if(l < 0)

		++neg, l *= -1;

	str[19] = '\0';

	do {

		i = l % 10;

		*sp-- = '0' + i;

		l /= 10;

	} while(l);

	if(neg)

		*sp-- = '-';

	return ++sp;

}