static Node *
combination(Node *s, Node *t)
{ Node *nc;
#ifdef NXT
Node *a = nonxt(s);
Node *b = nonxt(t);
if (tl_verbose)
{ printf("\tnonxtA: "); dump(a);
printf("\n\tnonxtB: "); dump(b);
printf("\n");
}
/* if there's only a X(f), its equivalent to true */
if (!a || !b)
nc = True;
else
nc = tl_nn(OR, a, b);
#else
nc = tl_nn(OR, s, t);
#endif
if (tl_verbose)
{ printf("\tcombo: "); dump(nc);
printf("\n");
}
return nc;
}
static void addcan(int tok, Node *n, Miscellaneous *miscell)
{ Node *m, *prev = ZN;
Node **ptr;
Node *N;
Symbol *s, *t; int cmp;
static char dumpbuf[BUFF_LEN];
static Node *can = ZN;
if (!n) return;
if (n->ntyp == tok)
{ addcan(tok, n->rgt, miscell);
addcan(tok, n->lft, miscell);
return;
}
#if 0
if ((tok == AND && n->ntyp == TRUE)
|| (tok == OR && n->ntyp == FALSE))
return;
#endif
N = dupnode(n);
if (!can)
{ can = N;
return;
}
s = DoDump(N,dumpbuf, miscell);
if (can->ntyp != tok) /* only one element in list so far */
{ ptr = &can;
goto insert;
}
/* there are at least 2 elements in list */
prev = ZN;
for (m = can; m->ntyp == tok && m->rgt; prev = m, m = m->rgt)
{ t = DoDump(m->lft,dumpbuf, miscell);
cmp = strcmp(s->name, t->name);
if (cmp == 0) /* duplicate */
return;
if (cmp < 0)
{ if (!prev)
{ can = tl_nn(tok, N, can, miscell);
return;
} else
{ ptr = &(prev->rgt);
goto insert;
} } }
/* new entry goes at the end of the list */
ptr = &(prev->rgt);
insert:
t = DoDump(*ptr,dumpbuf, miscell);
cmp = strcmp(s->name, t->name);
if (cmp == 0) /* duplicate */
return;
if (cmp < 0)
*ptr = tl_nn(tok, N, *ptr, miscell);
else
*ptr = tl_nn(tok, *ptr, N, miscell);
}
static void
addcan(int tok, Node *n)
{ Node *m, *prev = ZN;
Node **ptr;
Node *N;
Symbol *s, *t; int cmp;
if (!n) return;
if (n->ntyp == tok)
{ addcan(tok, n->rgt);
addcan(tok, n->lft);
return;
}
N = dupnode(n);
if (!can)
{ can = N;
return;
}
s = DoDump(N);
if (can->ntyp != tok) /* only one element in list so far */
{ ptr = &can;
goto insert;
}
/* there are at least 2 elements in list */
prev = ZN;
for (m = can; m->ntyp == tok && m->rgt; prev = m, m = m->rgt)
{ t = DoDump(m->lft);
if (t != ZS)
cmp = strcmp(s->name, t->name);
else
cmp = 0;
if (cmp == 0) /* duplicate */
return;
if (cmp < 0)
{ if (!prev)
{ can = tl_nn(tok, N, can);
return;
} else
{ ptr = &(prev->rgt);
goto insert;
} } }
/* new entry goes at the end of the list */
ptr = &(prev->rgt);
insert:
t = DoDump(*ptr);
cmp = strcmp(s->name, t->name);
if (cmp == 0) /* duplicate */
return;
if (cmp < 0)
*ptr = tl_nn(tok, N, *ptr);
else
*ptr = tl_nn(tok, *ptr, N);
}
static Node *
bin_minimal(Node *ptr)
{ if (ptr)
switch (ptr->ntyp) {
case IMPLIES:
return tl_nn(OR, Not(ptr->lft), ptr->rgt);
case EQUIV:
return tl_nn(OR,
tl_nn(AND,dupnode(ptr->lft),dupnode(ptr->rgt)),
tl_nn(AND,Not(ptr->lft),Not(ptr->rgt)));
}
return ptr;
}
static Node *
tl_level(int nr)
{ int i; Node *ptr = ZN;
if (nr < 0)
return tl_factor();
ptr = tl_level(nr-1);
again:
for (i = 0; i < 4; i++)
if (tl_yychar == prec[nr][i])
{ tl_yychar = tl_yylex();
ptr = tl_nn(prec[nr][i],
ptr, tl_level(nr-1));
ptr = bin_simpler(ptr);
goto again;
}
if (!ptr) tl_yyerror("syntax error");
#if 0
printf("level %d: ", nr);
tl_explain(ptr->ntyp);
printf("\n");
#endif
return ptr;
}
static Node *tl_level(int nr)
{
int i; Node *ptr = ZN;
Interval LocInter;
if (nr < 0)
return tl_factor();
ptr = tl_level(nr-1);
again:
for (i = 0; i < 4; i++)
if (tl_yychar == prec[nr][i])
{
if (nr==0 && (i==0 || i==1))
LocInter = TimeCon;
tl_yychar = tl_yylex();
ptr = tl_nn(prec[nr][i],ptr,tl_level(nr-1));
if (nr==0 && (i==0 || i==1))
ptr->time = LocInter;
if(tl_simp_log)
ptr = bin_simpler(ptr);
else
ptr = bin_minimal(ptr);
goto again;
}
if (!ptr) tl_yyerror("syntax error");
#if 0
printf("level %d: ", nr);
tl_explain(ptr->ntyp);
printf("\n");
#endif
return ptr;
}
Node *
twocases(Node *p)
{ Node *q;
/* 1: ([]p1 && []p2) == [](p1 && p2) */
/* 2: (<>p1 || <>p2) == <>(p1 || p2) */
if (!p) return p;
switch(p->ntyp) {
case AND:
case OR:
case U_OPER:
case V_OPER:
p->lft = twocases(p->lft);
p->rgt = twocases(p->rgt);
break;
#ifdef NXT
case NEXT:
#endif
case NOT:
p->lft = twocases(p->lft);
break;
default:
break;
}
if (p->ntyp == AND /* 1 */
&& p->lft->ntyp == V_OPER
&& p->lft->lft->ntyp == FALSE
&& p->rgt->ntyp == V_OPER
&& p->rgt->lft->ntyp == FALSE)
{ q = tl_nn(V_OPER, False,
tl_nn(AND, p->lft->rgt, p->rgt->rgt));
} else
if (p->ntyp == OR /* 2 */
&& p->lft->ntyp == U_OPER
&& p->lft->lft->ntyp == TRUE
&& p->rgt->ntyp == U_OPER
&& p->rgt->lft->ntyp == TRUE)
{ q = tl_nn(U_OPER, True,
tl_nn(OR, p->lft->rgt, p->rgt->rgt));
} else
q = p;
return q;
}
static Node *bin_minimal(Node *ptr)
{
Node *a, *b;
if (ptr)
{
switch (ptr->ntyp)
{
case IMPLIES:
return tl_nn(OR, Not(ptr->lft), ptr->rgt);
case EQUIV:
a = tl_nn(AND,dupnode(ptr->lft),dupnode(ptr->rgt));
b = tl_nn(AND,Not(ptr->lft),Not(ptr->rgt));
return tl_nn(OR, a, b);
}
}
return ptr;
}
static Node *bin_minimal(Node *ptr, Miscellaneous *miscell, int *cnt, char *uform, int *tl_yychar)
{
Node *a, *b;
if (ptr)
{
switch (ptr->ntyp)
{
case IMPLIES:
return tl_nn(OR, Not(ptr->lft), ptr->rgt, miscell);
case EQUIV:
a = tl_nn(AND,dupnode(ptr->lft),dupnode(ptr->rgt), miscell);
b = tl_nn(AND,Not(ptr->lft),Not(ptr->rgt), miscell);
return tl_nn(OR, a, b, miscell);
}
}
return ptr;
}
static Node *
flatten(Node *p)
{ Node *q, *r, *z = ZN;
for (q = p; q; q = q->nxt)
{ r = dupnode(q);
if (z)
z = tl_nn(AND, r, z);
else
z = r;
}
if (!z) return z;
z = rewrite(z);
return z;
}
static Node *tl_level(int nr, int *cnt, size_t hasuform, char *uform, Miscellaneous *miscell, int *tl_yychar)
{
int i; Node *ptr = ZN;
Interval LocInter;
int tl_simp_log_p = 0;
static int prec[2][4] = {
{ U_OPER, V_OPER, 0, 0}, /* left associative */
{ OR, AND, IMPLIES, EQUIV, }, /* left associative */
};
if (nr < 0)
return tl_factor(cnt, hasuform, uform, miscell, tl_yychar);
ptr = tl_level(nr-1, cnt, hasuform, uform, miscell, tl_yychar);
again:
for (i = 0; i < 4; i++)
if ((*tl_yychar) == prec[nr][i])
{
if (nr==0 && (i==0 || i==1))
LocInter = miscell->TimeCon;
(*tl_yychar) = tl_yylex(cnt, hasuform, uform, miscell, tl_yychar);
ptr = tl_nn(prec[nr][i],ptr,tl_level(nr-1, cnt, hasuform, uform, miscell, tl_yychar), miscell);
if (nr==0 && (i==0 || i==1))
ptr->time = LocInter;
if(tl_simp_log_p)
ptr = bin_simpler(ptr,miscell,cnt,uform, tl_yychar);
else
ptr = bin_minimal(ptr,miscell,cnt,uform, tl_yychar);
goto again;
}
if (!ptr) tl_yyerror("syntax error", cnt, uform, tl_yychar, miscell);
#if 0
printf("level %d: ", nr);
tl_explain(ptr->ntyp);
printf("\n");
#endif
return ptr;
}
static Node *
tl_factor(void)
{ Node *ptr = ZN;
switch (tl_yychar) {
case '(':
ptr = tl_formula();
if (tl_yychar != ')')
tl_yyerror("expected ')'");
tl_yychar = tl_yylex();
break;
case NOT:
ptr = tl_yylval;
tl_yychar = tl_yylex();
ptr->lft = tl_factor();
if (!ptr->lft)
{ fatal("malformed expression", (char *) 0);
}
ptr = push_negation(ptr);
break;
case ALWAYS:
tl_yychar = tl_yylex();
ptr = tl_factor();
#ifndef NO_OPT
if (ptr->ntyp == FALSE
|| ptr->ntyp == TRUE)
break; /* [] false == false */
if (ptr->ntyp == V_OPER)
{ if (ptr->lft->ntyp == FALSE)
break; /* [][]p = []p */
ptr = ptr->rgt; /* [] (p V q) = [] q */
}
#endif
ptr = tl_nn(V_OPER, False, ptr);
break;
#ifdef NXT
case NEXT:
tl_yychar = tl_yylex();
ptr = tl_factor();
if (ptr->ntyp == TRUE)
break; /* X true = true */
ptr = tl_nn(NEXT, ptr, ZN);
break;
#endif
case CEXPR:
tl_yychar = tl_yylex();
ptr = tl_factor();
if (ptr->ntyp != PREDICATE)
{ tl_yyerror("expected {...} after c_expr");
}
ptr = tl_nn(CEXPR, ptr, ZN);
break;
case EVENTUALLY:
tl_yychar = tl_yylex();
ptr = tl_factor();
#ifndef NO_OPT
if (ptr->ntyp == TRUE
|| ptr->ntyp == FALSE)
break; /* <> true == true */
if (ptr->ntyp == U_OPER
&& ptr->lft->ntyp == TRUE)
break; /* <><>p = <>p */
if (ptr->ntyp == U_OPER)
{ /* <> (p U q) = <> q */
ptr = ptr->rgt;
/* fall thru */
}
#endif
ptr = tl_nn(U_OPER, True, ptr);
break;
case PREDICATE:
ptr = tl_yylval;
tl_yychar = tl_yylex();
break;
case TRUE:
case FALSE:
ptr = tl_yylval;
tl_yychar = tl_yylex();
break;
}
if (!ptr) tl_yyerror("expected predicate");
#if 0
printf("factor: ");
tl_explain(ptr->ntyp);
printf("\n");
#endif
return ptr;
}
static Node *
bin_simpler(Node *ptr)
{ Node *a, *b;
if (ptr)
switch (ptr->ntyp) {
case U_OPER:
#ifndef NO_OPT
if (ptr->rgt->ntyp == TRUE
|| ptr->rgt->ntyp == FALSE
|| ptr->lft->ntyp == FALSE)
{ ptr = ptr->rgt;
break;
}
if (isequal(ptr->lft, ptr->rgt))
{ /* p U p = p */
ptr = ptr->rgt;
break;
}
if (ptr->lft->ntyp == U_OPER
&& isequal(ptr->lft->lft, ptr->rgt))
{ /* (p U q) U p = (q U p) */
ptr->lft = ptr->lft->rgt;
break;
}
if (ptr->rgt->ntyp == U_OPER
&& ptr->rgt->lft->ntyp == TRUE)
{ /* p U (T U q) = (T U q) */
ptr = ptr->rgt;
break;
}
#ifdef NXT
/* X p U X q == X (p U q) */
if (ptr->rgt->ntyp == NEXT
&& ptr->lft->ntyp == NEXT)
{ ptr = tl_nn(NEXT,
tl_nn(U_OPER,
ptr->lft->lft,
ptr->rgt->lft), ZN);
}
#endif
#endif
break;
case V_OPER:
#ifndef NO_OPT
if (ptr->rgt->ntyp == FALSE
|| ptr->rgt->ntyp == TRUE
|| ptr->lft->ntyp == TRUE)
{ ptr = ptr->rgt;
break;
}
if (isequal(ptr->lft, ptr->rgt))
{ /* p V p = p */
ptr = ptr->rgt;
break;
}
/* F V (p V q) == F V q */
if (ptr->lft->ntyp == FALSE
&& ptr->rgt->ntyp == V_OPER)
{ ptr->rgt = ptr->rgt->rgt;
break;
}
/* p V (F V q) == F V q */
if (ptr->rgt->ntyp == V_OPER
&& ptr->rgt->lft->ntyp == FALSE)
{ ptr->lft = False;
ptr->rgt = ptr->rgt->rgt;
break;
}
#endif
break;
case IMPLIES:
#ifndef NO_OPT
if (isequal(ptr->lft, ptr->rgt))
{ ptr = True;
break;
}
#endif
ptr = tl_nn(OR, Not(ptr->lft), ptr->rgt);
ptr = rewrite(ptr);
break;
case EQUIV:
#ifndef NO_OPT
if (isequal(ptr->lft, ptr->rgt))
{ ptr = True;
break;
}
#endif
a = rewrite(tl_nn(AND,
dupnode(ptr->lft),
dupnode(ptr->rgt)));
b = rewrite(tl_nn(AND,
Not(ptr->lft),
Not(ptr->rgt)));
ptr = tl_nn(OR, a, b);
ptr = rewrite(ptr);
break;
case AND:
#ifndef NO_OPT
/* p && (q U p) = p */
if (ptr->rgt->ntyp == U_OPER
&& isequal(ptr->rgt->rgt, ptr->lft))
{ ptr = ptr->lft;
break;
}
if (ptr->lft->ntyp == U_OPER
&& isequal(ptr->lft->rgt, ptr->rgt))
{ ptr = ptr->rgt;
break;
}
/* p && (q V p) == q V p */
if (ptr->rgt->ntyp == V_OPER
&& isequal(ptr->rgt->rgt, ptr->lft))
{ ptr = ptr->rgt;
break;
}
if (ptr->lft->ntyp == V_OPER
&& isequal(ptr->lft->rgt, ptr->rgt))
{ ptr = ptr->lft;
break;
}
/* (p U q) && (r U q) = (p && r) U q*/
if (ptr->rgt->ntyp == U_OPER
&& ptr->lft->ntyp == U_OPER
&& isequal(ptr->rgt->rgt, ptr->lft->rgt))
{ ptr = tl_nn(U_OPER,
tl_nn(AND, ptr->lft->lft, ptr->rgt->lft),
ptr->lft->rgt);
break;
}
/* (p V q) && (p V r) = p V (q && r) */
if (ptr->rgt->ntyp == V_OPER
&& ptr->lft->ntyp == V_OPER
&& isequal(ptr->rgt->lft, ptr->lft->lft))
{ ptr = tl_nn(V_OPER,
ptr->rgt->lft,
tl_nn(AND, ptr->lft->rgt, ptr->rgt->rgt));
break;
}
#ifdef NXT
/* X p && X q == X (p && q) */
if (ptr->rgt->ntyp == NEXT
&& ptr->lft->ntyp == NEXT)
{ ptr = tl_nn(NEXT,
tl_nn(AND,
ptr->rgt->lft,
ptr->lft->lft), ZN);
break;
}
#endif
if (isequal(ptr->lft, ptr->rgt) /* (p && p) == p */
|| ptr->rgt->ntyp == FALSE /* (p && F) == F */
|| ptr->lft->ntyp == TRUE) /* (T && p) == p */
{ ptr = ptr->rgt;
break;
}
if (ptr->rgt->ntyp == TRUE /* (p && T) == p */
|| ptr->lft->ntyp == FALSE) /* (F && p) == F */
{ ptr = ptr->lft;
break;
}
/* (p V q) && (r U q) == p V q */
if (ptr->rgt->ntyp == U_OPER
&& ptr->lft->ntyp == V_OPER
&& isequal(ptr->lft->rgt, ptr->rgt->rgt))
{ ptr = ptr->lft;
break;
}
#endif
break;
case OR:
#ifndef NO_OPT
/* p || (q U p) == q U p */
if (ptr->rgt->ntyp == U_OPER
&& isequal(ptr->rgt->rgt, ptr->lft))
{ ptr = ptr->rgt;
break;
}
/* p || (q V p) == p */
if (ptr->rgt->ntyp == V_OPER
&& isequal(ptr->rgt->rgt, ptr->lft))
{ ptr = ptr->lft;
break;
}
/* (p U q) || (p U r) = p U (q || r) */
if (ptr->rgt->ntyp == U_OPER
&& ptr->lft->ntyp == U_OPER
&& isequal(ptr->rgt->lft, ptr->lft->lft))
{ ptr = tl_nn(U_OPER,
ptr->rgt->lft,
tl_nn(OR, ptr->lft->rgt, ptr->rgt->rgt));
break;
}
if (isequal(ptr->lft, ptr->rgt) /* (p || p) == p */
|| ptr->rgt->ntyp == FALSE /* (p || F) == p */
|| ptr->lft->ntyp == TRUE) /* (T || p) == T */
{ ptr = ptr->lft;
break;
}
if (ptr->rgt->ntyp == TRUE /* (p || T) == T */
|| ptr->lft->ntyp == FALSE) /* (F || p) == p */
{ ptr = ptr->rgt;
break;
}
/* (p V q) || (r V q) = (p || r) V q */
if (ptr->rgt->ntyp == V_OPER
&& ptr->lft->ntyp == V_OPER
&& isequal(ptr->lft->rgt, ptr->rgt->rgt))
{ ptr = tl_nn(V_OPER,
tl_nn(OR, ptr->lft->lft, ptr->rgt->lft),
ptr->rgt->rgt);
break;
}
/* (p V q) || (r U q) == r U q */
if (ptr->rgt->ntyp == U_OPER
&& ptr->lft->ntyp == V_OPER
&& isequal(ptr->lft->rgt, ptr->rgt->rgt))
{ ptr = ptr->rgt;
break;
}
#endif
break;
}
return ptr;
}
static int
tl_lex(void)
{ int c;
do {
c = tl_Getchar();
yytext_ltl2ba[0] = (char ) c;
yytext_ltl2ba[1] = '\0';
if (c <= 0)
{ Token(';');
}
} while (c == ' '); /* '\t' is removed in tl_main.c */
if (islower(c))
{ getword(c, isalnum_);
if (strcmp("true", yytext_ltl2ba) == 0)
{ Token(TRUE);
}
if (strcmp("false", yytext_ltl2ba) == 0)
{ Token(FALSE);
}
tl_yylval = tl_nn(PREDICATE,ZN,ZN);
tl_yylval->sym = tl_lookup(yytext_ltl2ba);
return PREDICATE;
}
if (c == '<')
{ c = tl_Getchar();
if (c == '>')
{ Token(EVENTUALLY);
}
if (c != '-')
{ tl_UnGetchar();
tl_yyerror("expected '<>' or '<->'");
}
c = tl_Getchar();
if (c == '>')
{ Token(EQUIV);
}
tl_UnGetchar();
tl_yyerror("expected '<->'");
}
switch (c) {
case '/' : c = follow('\\', AND, '/'); break;
case '\\': c = follow('/', OR, '\\'); break;
case '&' : c = follow('&', AND, '&'); break;
case '|' : c = follow('|', OR, '|'); break;
case '[' : c = follow(']', ALWAYS, '['); break;
case '-' : c = follow('>', IMPLIES, '-'); break;
case '!' : c = NOT; break;
case 'U' : c = U_OPER; break;
case 'V' : c = V_OPER; break;
#ifdef NXT
case 'X' : c = NEXT; break;
#endif
default : break;
}
Token(c);
}
static Node *bin_simpler(Node *ptr, Miscellaneous *miscell, int *cnt, char *uform, int *tl_yychar)
{ Node *a, *b;
if (ptr)
switch (ptr->ntyp) {
case U_OPER:
if (ptr->rgt->ntyp == TRUE
|| ptr->rgt->ntyp == FALSE
|| ptr->lft->ntyp == FALSE)
{ ptr = ptr->rgt;
break;
}
if (implies(ptr->lft, ptr->rgt, cnt, uform, tl_yychar, miscell)) /* NEW */
{ ptr = ptr->rgt;
break;
}
if (ptr->lft->ntyp == U_OPER
&& isequal(ptr->lft->lft, ptr->rgt, cnt, uform, tl_yychar, miscell))
{ /* (p U q) U p = (q U p) */
ptr->lft = ptr->lft->rgt;
break;
}
if (ptr->rgt->ntyp == U_OPER
&& implies(ptr->lft, ptr->rgt->lft, cnt, uform, tl_yychar, miscell))
{ /* NEW */
ptr = ptr->rgt;
break;
}
/* X p U X q == X (p U q) */
if (ptr->rgt->ntyp == NEXT
&& ptr->lft->ntyp == NEXT)
{ ptr = tl_nn(NEXT,
tl_nn(U_OPER,
ptr->lft->lft,
ptr->rgt->lft, miscell), ZN, miscell);
break;
}
/* NEW : F X p == X F p */
if (ptr->lft->ntyp == TRUE &&
ptr->rgt->ntyp == NEXT) {
ptr = tl_nn(NEXT, tl_nn(U_OPER, True, ptr->rgt->lft, miscell), ZN, miscell);
break;
}
/* NEW : F G F p == G F p */
if (ptr->lft->ntyp == TRUE &&
ptr->rgt->ntyp == V_OPER &&
ptr->rgt->lft->ntyp == FALSE &&
ptr->rgt->rgt->ntyp == U_OPER &&
ptr->rgt->rgt->lft->ntyp == TRUE) {
ptr = ptr->rgt;
break;
}
/* NEW */
if (ptr->lft->ntyp != TRUE &&
implies(push_negation(tl_nn(NOT, dupnode(ptr->rgt), ZN, miscell), miscell, cnt, uform, tl_yychar), ptr->lft, cnt, uform, tl_yychar, miscell))
{ ptr->lft = True;
break;
}
break;
case V_OPER:
if (ptr->rgt->ntyp == FALSE
|| ptr->rgt->ntyp == TRUE
|| ptr->lft->ntyp == TRUE)
{ ptr = ptr->rgt;
break;
}
if (implies(ptr->rgt, ptr->lft, cnt, uform, tl_yychar, miscell))
{ /* p V p = p */
ptr = ptr->rgt;
break;
}
/* F V (p V q) == F V q */
if (ptr->lft->ntyp == FALSE
&& ptr->rgt->ntyp == V_OPER)
{ ptr->rgt = ptr->rgt->rgt;
break;
}
/* NEW : G X p == X G p */
if (ptr->lft->ntyp == FALSE &&
ptr->rgt->ntyp == NEXT) {
ptr = tl_nn(NEXT, tl_nn(V_OPER, False, ptr->rgt->lft, miscell), ZN, miscell);
break;
}
/* NEW : G F G p == F G p */
if (ptr->lft->ntyp == FALSE &&
ptr->rgt->ntyp == U_OPER &&
ptr->rgt->lft->ntyp == TRUE &&
ptr->rgt->rgt->ntyp == V_OPER &&
ptr->rgt->rgt->lft->ntyp == FALSE) {
ptr = ptr->rgt;
break;
}
/* NEW */
if (ptr->rgt->ntyp == V_OPER
&& implies(ptr->rgt->lft, ptr->lft, cnt, uform, tl_yychar, miscell))
{ ptr = ptr->rgt;
break;
}
/* NEW */
if (ptr->lft->ntyp != FALSE &&
implies(ptr->lft,
push_negation(tl_nn(NOT, dupnode(ptr->rgt), ZN, miscell), miscell, cnt, uform, tl_yychar), cnt, uform, tl_yychar, miscell))
{ ptr->lft = False;
break;
}
break;
case NEXT:
/* NEW : X G F p == G F p */
if (ptr->lft->ntyp == V_OPER &&
ptr->lft->lft->ntyp == FALSE &&
ptr->lft->rgt->ntyp == U_OPER &&
ptr->lft->rgt->lft->ntyp == TRUE) {
break;
}
/* NEW : X F G p == F G p */
if (ptr->lft->ntyp == U_OPER &&
ptr->lft->lft->ntyp == TRUE &&
ptr->lft->rgt->ntyp == V_OPER &&
ptr->lft->rgt->lft->ntyp == FALSE) {
break;
}
break;
case ALWAYS:
/* NEW : [] G F p == G F p */
if (ptr->rgt->ntyp == V_OPER &&
ptr->rgt->rgt->ntyp == FALSE &&
ptr->rgt->lft->ntyp == U_OPER &&
ptr->rgt->lft->rgt->ntyp == TRUE) {
ptr = ptr->rgt;
break;
}
/* NEW : [] F G p == F G p */
if (ptr->rgt->ntyp == U_OPER &&
ptr->rgt->rgt->ntyp == TRUE &&
ptr->rgt->lft->ntyp == V_OPER &&
ptr->rgt->lft->rgt->ntyp == FALSE) {
ptr = ptr->rgt;
break;
}
break;
case IMPLIES:
if (implies(ptr->lft, ptr->rgt, cnt, uform, tl_yychar, miscell))
{ ptr = True;
break;
}
ptr = tl_nn(OR, Not(ptr->lft), ptr->rgt, miscell);
ptr = canonical(right_linked(ptr), miscell, cnt, uform, tl_yychar);
break;
case EQUIV:
if (implies(ptr->lft, ptr->rgt, cnt, uform, tl_yychar, miscell) &&
implies(ptr->rgt, ptr->lft, cnt, uform, tl_yychar, miscell))
{ ptr = True;
break;
}
a = canonical(right_linked(tl_nn(AND,
dupnode(ptr->lft),
dupnode(ptr->rgt), miscell)), miscell, cnt, uform, tl_yychar);
b = canonical(right_linked(tl_nn(AND,
Not(ptr->lft),
Not(ptr->rgt), miscell)), miscell, cnt, uform, tl_yychar);
ptr = tl_nn(OR, a, b, miscell);
ptr = canonical(right_linked(ptr), miscell, cnt, uform, tl_yychar);
break;
case AND:
/* p && (q U p) = p */
if (ptr->rgt->ntyp == U_OPER
&& isequal(ptr->rgt->rgt, ptr->lft, cnt, uform, tl_yychar, miscell))
{ ptr = ptr->lft;
break;
}
if (ptr->lft->ntyp == U_OPER
&& isequal(ptr->lft->rgt, ptr->rgt, cnt, uform, tl_yychar, miscell))
{ ptr = ptr->rgt;
break;
}
/* p && (q V p) == q V p */
if (ptr->rgt->ntyp == V_OPER
&& isequal(ptr->rgt->rgt, ptr->lft, cnt, uform, tl_yychar, miscell))
{ ptr = ptr->rgt;
break;
}
if (ptr->lft->ntyp == V_OPER
&& isequal(ptr->lft->rgt, ptr->rgt, cnt, uform, tl_yychar, miscell))
{ ptr = ptr->lft;
break;
}
/* (p U q) && (r U q) = (p && r) U q*/
if (ptr->rgt->ntyp == U_OPER
&& ptr->lft->ntyp == U_OPER
&& isequal(ptr->rgt->rgt, ptr->lft->rgt, cnt, uform, tl_yychar, miscell))
{ ptr = tl_nn(U_OPER,
tl_nn(AND, ptr->lft->lft, ptr->rgt->lft, miscell),
ptr->lft->rgt, miscell);
break;
}
/* (p V q) && (p V r) = p V (q && r) */
if (ptr->rgt->ntyp == V_OPER
&& ptr->lft->ntyp == V_OPER
&& isequal(ptr->rgt->lft, ptr->lft->lft, cnt, uform, tl_yychar, miscell))
{ ptr = tl_nn(V_OPER,
ptr->rgt->lft,
tl_nn(AND, ptr->lft->rgt, ptr->rgt->rgt, miscell), miscell);
break;
}
/* X p && X q == X (p && q) */
if (ptr->rgt->ntyp == NEXT
&& ptr->lft->ntyp == NEXT)
{ ptr = tl_nn(NEXT,
tl_nn(AND,
ptr->rgt->lft,
ptr->lft->lft, miscell), ZN, miscell);
break;
}
/* (p V q) && (r U q) == p V q */
if (ptr->rgt->ntyp == U_OPER
&& ptr->lft->ntyp == V_OPER
&& isequal(ptr->lft->rgt, ptr->rgt->rgt, cnt, uform, tl_yychar, miscell))
{ ptr = ptr->lft;
break;
}
if (isequal(ptr->lft, ptr->rgt, cnt, uform, tl_yychar, miscell) /* (p && p) == p */
|| ptr->rgt->ntyp == FALSE /* (p && F) == F */
|| ptr->lft->ntyp == TRUE /* (T && p) == p */
|| implies(ptr->rgt, ptr->lft, cnt, uform, tl_yychar, miscell))/* NEW */
{ ptr = ptr->rgt;
break;
}
if (ptr->rgt->ntyp == TRUE /* (p && T) == p */
|| ptr->lft->ntyp == FALSE /* (F && p) == F */
|| implies(ptr->lft, ptr->rgt, cnt, uform, tl_yychar, miscell))/* NEW */
{ ptr = ptr->lft;
break;
}
/* NEW : F G p && F G q == F G (p && q) */
if (ptr->lft->ntyp == U_OPER &&
ptr->lft->lft->ntyp == TRUE &&
ptr->lft->rgt->ntyp == V_OPER &&
ptr->lft->rgt->lft->ntyp == FALSE &&
ptr->rgt->ntyp == U_OPER &&
ptr->rgt->lft->ntyp == TRUE &&
ptr->rgt->rgt->ntyp == V_OPER &&
ptr->rgt->rgt->lft->ntyp == FALSE)
{
ptr = tl_nn(U_OPER, True,
tl_nn(V_OPER, False,
tl_nn(AND, ptr->lft->rgt->rgt,
ptr->rgt->rgt->rgt, miscell), miscell), miscell);
break;
}
/* NEW */
if (implies(ptr->lft,
push_negation(tl_nn(NOT, dupnode(ptr->rgt), ZN, miscell), miscell, cnt, uform, tl_yychar), cnt, uform, tl_yychar, miscell)
|| implies(ptr->rgt,
push_negation(tl_nn(NOT, dupnode(ptr->lft), ZN, miscell), miscell, cnt, uform, tl_yychar), cnt, uform, tl_yychar, miscell))
{ ptr = False;
break;
}
break;
case OR:
/* p || (q U p) == q U p */
if (ptr->rgt->ntyp == U_OPER
&& isequal(ptr->rgt->rgt, ptr->lft, cnt, uform, tl_yychar, miscell))
{ ptr = ptr->rgt;
break;
}
/* p || (q V p) == p */
if (ptr->rgt->ntyp == V_OPER
&& isequal(ptr->rgt->rgt, ptr->lft, cnt, uform, tl_yychar, miscell))
{ ptr = ptr->lft;
break;
}
/* (p U q) || (p U r) = p U (q || r) */
if (ptr->rgt->ntyp == U_OPER
&& ptr->lft->ntyp == U_OPER
&& isequal(ptr->rgt->lft, ptr->lft->lft, cnt, uform, tl_yychar, miscell))
{ ptr = tl_nn(U_OPER,
ptr->rgt->lft,
tl_nn(OR, ptr->lft->rgt, ptr->rgt->rgt, miscell), miscell);
break;
}
if (isequal(ptr->lft, ptr->rgt, cnt, uform, tl_yychar, miscell) /* (p || p) == p */
|| ptr->rgt->ntyp == FALSE /* (p || F) == p */
|| ptr->lft->ntyp == TRUE /* (T || p) == T */
|| implies(ptr->rgt, ptr->lft, cnt, uform, tl_yychar, miscell))/* NEW */
{ ptr = ptr->lft;
break;
}
if (ptr->rgt->ntyp == TRUE /* (p || T) == T */
|| ptr->lft->ntyp == FALSE /* (F || p) == p */
|| implies(ptr->lft, ptr->rgt, cnt, uform, tl_yychar, miscell))/* NEW */
{ ptr = ptr->rgt;
break;
}
/* (p V q) || (r V q) = (p || r) V q */
if (ptr->rgt->ntyp == V_OPER
&& ptr->lft->ntyp == V_OPER
&& isequal(ptr->lft->rgt, ptr->rgt->rgt, cnt, uform, tl_yychar, miscell))
{ ptr = tl_nn(V_OPER,
tl_nn(OR, ptr->lft->lft, ptr->rgt->lft, miscell),
ptr->rgt->rgt, miscell);
break;
}
/* (p V q) || (r U q) == r U q */
if (ptr->rgt->ntyp == U_OPER
&& ptr->lft->ntyp == V_OPER
&& isequal(ptr->lft->rgt, ptr->rgt->rgt, cnt, uform, tl_yychar, miscell))
{ ptr = ptr->rgt;
break;
}
/* NEW : G F p || G F q == G F (p || q) */
if (ptr->lft->ntyp == V_OPER &&
ptr->lft->lft->ntyp == FALSE &&
ptr->lft->rgt->ntyp == U_OPER &&
ptr->lft->rgt->lft->ntyp == TRUE &&
ptr->rgt->ntyp == V_OPER &&
ptr->rgt->lft->ntyp == FALSE &&
ptr->rgt->rgt->ntyp == U_OPER &&
ptr->rgt->rgt->lft->ntyp == TRUE)
{
ptr = tl_nn(V_OPER, False,
tl_nn(U_OPER, True,
tl_nn(OR, ptr->lft->rgt->rgt,
ptr->rgt->rgt->rgt, miscell), miscell), miscell);
break;
}
/* NEW */
if (implies(push_negation(tl_nn(NOT, dupnode(ptr->rgt), ZN, miscell), miscell, cnt, uform, tl_yychar),
ptr->lft, cnt, uform, tl_yychar, miscell)
|| implies(push_negation(tl_nn(NOT, dupnode(ptr->lft), ZN, miscell), miscell, cnt, uform, tl_yychar),
ptr->rgt, cnt, uform, tl_yychar, miscell))
{ ptr = True;
break;
}
break;
}
return ptr;
}
static Node *bin_simpler(Node *ptr)
{ Node *a, *b;
if (ptr)
switch (ptr->ntyp) {
case U_OPER:
if (ptr->rgt->ntyp == TRUE
|| ptr->rgt->ntyp == FALSE
|| ptr->lft->ntyp == FALSE)
{ ptr = ptr->rgt;
break;
}
if (implies(ptr->lft, ptr->rgt)) /* NEW */
{ ptr = ptr->rgt;
break;
}
if (ptr->lft->ntyp == U_OPER
&& isequal(ptr->lft->lft, ptr->rgt))
{ /* (p U q) U p = (q U p) */
ptr->lft = ptr->lft->rgt;
break;
}
if (ptr->rgt->ntyp == U_OPER
&& implies(ptr->lft, ptr->rgt->lft))
{ /* NEW */
ptr = ptr->rgt;
break;
}
/* X p U X q == X (p U q) */
if (ptr->rgt->ntyp == NEXT
&& ptr->lft->ntyp == NEXT)
{ ptr = tl_nn(NEXT,
tl_nn(U_OPER,
ptr->lft->lft,
ptr->rgt->lft), ZN);
break;
}
/* NEW : F X p == X F p */
if (ptr->lft->ntyp == TRUE &&
ptr->rgt->ntyp == NEXT) {
ptr = tl_nn(NEXT, tl_nn(U_OPER, True, ptr->rgt->lft), ZN);
break;
}
/* NEW : F G F p == G F p */
if (ptr->lft->ntyp == TRUE &&
ptr->rgt->ntyp == V_OPER &&
ptr->rgt->lft->ntyp == FALSE &&
ptr->rgt->rgt->ntyp == U_OPER &&
ptr->rgt->rgt->lft->ntyp == TRUE) {
ptr = ptr->rgt;
break;
}
/* NEW */
if (ptr->lft->ntyp != TRUE &&
implies(push_negation(tl_nn(NOT, dupnode(ptr->rgt), ZN)), ptr->lft))
{ ptr->lft = True;
break;
}
break;
case V_OPER:
if (ptr->rgt->ntyp == FALSE
|| ptr->rgt->ntyp == TRUE
|| ptr->lft->ntyp == TRUE)
{ ptr = ptr->rgt;
break;
}
if (implies(ptr->rgt, ptr->lft))
{ /* p V p = p */
ptr = ptr->rgt;
break;
}
/* F V (p V q) == F V q */
if (ptr->lft->ntyp == FALSE
&& ptr->rgt->ntyp == V_OPER)
{ ptr->rgt = ptr->rgt->rgt;
break;
}
/* NEW : G X p == X G p */
if (ptr->lft->ntyp == FALSE &&
ptr->rgt->ntyp == NEXT) {
ptr = tl_nn(NEXT, tl_nn(V_OPER, False, ptr->rgt->lft), ZN);
break;
}
/* NEW : G F G p == F G p */
if (ptr->lft->ntyp == FALSE &&
ptr->rgt->ntyp == U_OPER &&
ptr->rgt->lft->ntyp == TRUE &&
ptr->rgt->rgt->ntyp == V_OPER &&
ptr->rgt->rgt->lft->ntyp == FALSE) {
ptr = ptr->rgt;
break;
}
/* NEW */
if (ptr->rgt->ntyp == V_OPER
&& implies(ptr->rgt->lft, ptr->lft))
{ ptr = ptr->rgt;
break;
}
/* NEW */
if (ptr->lft->ntyp != FALSE &&
implies(ptr->lft,
push_negation(tl_nn(NOT, dupnode(ptr->rgt), ZN))))
{ ptr->lft = False;
break;
}
break;
case NEXT:
/* NEW : X G F p == G F p */
if (ptr->lft->ntyp == V_OPER &&
ptr->lft->lft->ntyp == FALSE &&
ptr->lft->rgt->ntyp == U_OPER &&
ptr->lft->rgt->lft->ntyp == TRUE) {
ptr = ptr->lft;
break;
}
/* NEW : X F G p == F G p */
if (ptr->lft->ntyp == U_OPER &&
ptr->lft->lft->ntyp == TRUE &&
ptr->lft->rgt->ntyp == V_OPER &&
ptr->lft->rgt->lft->ntyp == FALSE) {
ptr = ptr->lft;
break;
}
break;
case IMPLIES:
if (implies(ptr->lft, ptr->rgt))
{ ptr = True;
break;
}
ptr = tl_nn(OR, Not(ptr->lft), ptr->rgt);
ptr = rewrite(ptr);
break;
case EQUIV:
if (implies(ptr->lft, ptr->rgt) &&
implies(ptr->rgt, ptr->lft))
{ ptr = True;
break;
}
a = rewrite(tl_nn(AND,
dupnode(ptr->lft),
dupnode(ptr->rgt)));
b = rewrite(tl_nn(AND,
Not(ptr->lft),
Not(ptr->rgt)));
ptr = tl_nn(OR, a, b);
ptr = rewrite(ptr);
break;
case AND:
/* p && (q U p) = p */
if (ptr->rgt->ntyp == U_OPER
&& isequal(ptr->rgt->rgt, ptr->lft))
{ ptr = ptr->lft;
break;
}
if (ptr->lft->ntyp == U_OPER
&& isequal(ptr->lft->rgt, ptr->rgt))
{ ptr = ptr->rgt;
break;
}
/* p && (q V p) == q V p */
if (ptr->rgt->ntyp == V_OPER
&& isequal(ptr->rgt->rgt, ptr->lft))
{ ptr = ptr->rgt;
break;
}
if (ptr->lft->ntyp == V_OPER
&& isequal(ptr->lft->rgt, ptr->rgt))
{ ptr = ptr->lft;
break;
}
/* (p U q) && (r U q) = (p && r) U q*/
if (ptr->rgt->ntyp == U_OPER
&& ptr->lft->ntyp == U_OPER
&& isequal(ptr->rgt->rgt, ptr->lft->rgt))
{ ptr = tl_nn(U_OPER,
tl_nn(AND, ptr->lft->lft, ptr->rgt->lft),
ptr->lft->rgt);
break;
}
/* (p V q) && (p V r) = p V (q && r) */
if (ptr->rgt->ntyp == V_OPER
&& ptr->lft->ntyp == V_OPER
&& isequal(ptr->rgt->lft, ptr->lft->lft))
{ ptr = tl_nn(V_OPER,
ptr->rgt->lft,
tl_nn(AND, ptr->lft->rgt, ptr->rgt->rgt));
break;
}
/* X p && X q == X (p && q) */
if (ptr->rgt->ntyp == NEXT
&& ptr->lft->ntyp == NEXT)
{ ptr = tl_nn(NEXT,
tl_nn(AND,
ptr->rgt->lft,
ptr->lft->lft), ZN);
break;
}
/* (p V q) && (r U q) == p V q */
if (ptr->rgt->ntyp == U_OPER
&& ptr->lft->ntyp == V_OPER
&& isequal(ptr->lft->rgt, ptr->rgt->rgt))
{ ptr = ptr->lft;
break;
}
if (isequal(ptr->lft, ptr->rgt) /* (p && p) == p */
|| ptr->rgt->ntyp == FALSE /* (p && F) == F */
|| ptr->lft->ntyp == TRUE /* (T && p) == p */
|| implies(ptr->rgt, ptr->lft))/* NEW */
{ ptr = ptr->rgt;
break;
}
if (ptr->rgt->ntyp == TRUE /* (p && T) == p */
|| ptr->lft->ntyp == FALSE /* (F && p) == F */
|| implies(ptr->lft, ptr->rgt))/* NEW */
{ ptr = ptr->lft;
break;
}
/* NEW : F G p && F G q == F G (p && q) */
if (ptr->lft->ntyp == U_OPER &&
ptr->lft->lft->ntyp == TRUE &&
ptr->lft->rgt->ntyp == V_OPER &&
ptr->lft->rgt->lft->ntyp == FALSE &&
ptr->rgt->ntyp == U_OPER &&
ptr->rgt->lft->ntyp == TRUE &&
ptr->rgt->rgt->ntyp == V_OPER &&
ptr->rgt->rgt->lft->ntyp == FALSE)
{
ptr = tl_nn(U_OPER, True,
tl_nn(V_OPER, False,
tl_nn(AND, ptr->lft->rgt->rgt,
ptr->rgt->rgt->rgt)));
break;
}
/* NEW */
if (implies(ptr->lft,
push_negation(tl_nn(NOT, dupnode(ptr->rgt), ZN)))
|| implies(ptr->rgt,
push_negation(tl_nn(NOT, dupnode(ptr->lft), ZN))))
{ ptr = False;
break;
}
break;
case OR:
/* p || (q U p) == q U p */
if (ptr->rgt->ntyp == U_OPER
&& isequal(ptr->rgt->rgt, ptr->lft))
{ ptr = ptr->rgt;
break;
}
/* p || (q V p) == p */
if (ptr->rgt->ntyp == V_OPER
&& isequal(ptr->rgt->rgt, ptr->lft))
{ ptr = ptr->lft;
break;
}
/* (p U q) || (p U r) = p U (q || r) */
if (ptr->rgt->ntyp == U_OPER
&& ptr->lft->ntyp == U_OPER
&& isequal(ptr->rgt->lft, ptr->lft->lft))
{ ptr = tl_nn(U_OPER,
ptr->rgt->lft,
tl_nn(OR, ptr->lft->rgt, ptr->rgt->rgt));
break;
}
if (isequal(ptr->lft, ptr->rgt) /* (p || p) == p */
|| ptr->rgt->ntyp == FALSE /* (p || F) == p */
|| ptr->lft->ntyp == TRUE /* (T || p) == T */
|| implies(ptr->rgt, ptr->lft))/* NEW */
{ ptr = ptr->lft;
break;
}
if (ptr->rgt->ntyp == TRUE /* (p || T) == T */
|| ptr->lft->ntyp == FALSE /* (F || p) == p */
|| implies(ptr->lft, ptr->rgt))/* NEW */
{ ptr = ptr->rgt;
break;
}
/* (p V q) || (r V q) = (p || r) V q */
if (ptr->rgt->ntyp == V_OPER
&& ptr->lft->ntyp == V_OPER
&& isequal(ptr->lft->rgt, ptr->rgt->rgt))
{ ptr = tl_nn(V_OPER,
tl_nn(OR, ptr->lft->lft, ptr->rgt->lft),
ptr->rgt->rgt);
break;
}
/* (p V q) || (r U q) == r U q */
if (ptr->rgt->ntyp == U_OPER
&& ptr->lft->ntyp == V_OPER
&& isequal(ptr->lft->rgt, ptr->rgt->rgt))
{ ptr = ptr->rgt;
break;
}
/* NEW : G F p || G F q == G F (p || q) */
if (ptr->lft->ntyp == V_OPER &&
ptr->lft->lft->ntyp == FALSE &&
ptr->lft->rgt->ntyp == U_OPER &&
ptr->lft->rgt->lft->ntyp == TRUE &&
ptr->rgt->ntyp == V_OPER &&
ptr->rgt->lft->ntyp == FALSE &&
ptr->rgt->rgt->ntyp == U_OPER &&
ptr->rgt->rgt->lft->ntyp == TRUE)
{
ptr = tl_nn(V_OPER, False,
tl_nn(U_OPER, True,
tl_nn(OR, ptr->lft->rgt->rgt,
ptr->rgt->rgt->rgt)));
break;
}
/* NEW */
if (implies(push_negation(tl_nn(NOT, dupnode(ptr->rgt), ZN)),
ptr->lft)
|| implies(push_negation(tl_nn(NOT, dupnode(ptr->lft), ZN)),
ptr->rgt))
{ ptr = True;
break;
}
break;
}
return ptr;
}
static Node *
tl_factor(void)
{ Node *ptr = ZN;
switch (tl_yychar) {
case '(':
ptr = tl_formula();
if (tl_yychar != ')')
tl_yyerror("expected ')'");
tl_yychar = tl_yylex();
goto simpl;
case NOT:
ptr = tl_yylval;
tl_yychar = tl_yylex();
ptr->lft = tl_factor();
ptr = push_negation(ptr);
goto simpl;
case ALWAYS:
tl_yychar = tl_yylex();
ptr = tl_factor();
if(tl_simp_log) {
if (ptr->ntyp == FALSE
|| ptr->ntyp == TRUE)
break; /* [] false == false */
if (ptr->ntyp == V_OPER)
{ if (ptr->lft->ntyp == FALSE)
break; /* [][]p = []p */
ptr = ptr->rgt; /* [] (p V q) = [] q */
}
}
ptr = tl_nn(V_OPER, False, ptr);
goto simpl;
#ifdef NXT
case NEXT:
tl_yychar = tl_yylex();
ptr = tl_factor();
if ((ptr->ntyp == TRUE || ptr->ntyp == FALSE)&& tl_simp_log)
break; /* X true = true , X false = false */
ptr = tl_nn(NEXT, ptr, ZN);
goto simpl;
#endif
case EVENTUALLY:
tl_yychar = tl_yylex();
ptr = tl_factor();
if(tl_simp_log) {
if (ptr->ntyp == TRUE
|| ptr->ntyp == FALSE)
break; /* <> true == true */
if (ptr->ntyp == U_OPER
&& ptr->lft->ntyp == TRUE)
break; /* <><>p = <>p */
if (ptr->ntyp == U_OPER)
{ /* <> (p U q) = <> q */
ptr = ptr->rgt;
/* fall thru */
}
}
ptr = tl_nn(U_OPER, True, ptr);
simpl:
if (tl_simp_log)
ptr = bin_simpler(ptr);
break;
case PREDICATE:
ptr = tl_yylval;
tl_yychar = tl_yylex();
break;
case TRUE:
case FALSE:
ptr = tl_yylval;
tl_yychar = tl_yylex();
break;
}
if (!ptr) tl_yyerror("expected predicate");
#if 0
printf("factor: ");
tl_explain(ptr->ntyp);
printf("\n");
#endif
return ptr;
}
static Node *tl_factor(int *cnt, size_t hasuform, char *uform, Miscellaneous *miscell, int *tl_yychar)
{
Node *ptr = ZN;
int tl_simp_log_p = 0;
switch ((*tl_yychar))
{
case '(':
ptr = tl_formula(cnt, hasuform, uform, miscell, tl_yychar);
if ((*tl_yychar) != ')')
tl_yyerror("expected ')'", cnt, uform, tl_yychar, miscell);
(*tl_yychar) = tl_yylex(cnt, hasuform, uform, miscell, tl_yychar);
goto simpl;
case NOT:
ptr = miscell->tl_yylval;
(*tl_yychar) = tl_yylex(cnt, hasuform, uform, miscell, tl_yychar);
ptr->lft = tl_factor(cnt, hasuform, uform, miscell, tl_yychar);
ptr = push_negation(ptr, miscell, cnt, uform, tl_yychar);
goto simpl;
case ALWAYS:
ptr = tl_nn(ALWAYS, False, ZN, miscell);
ptr->time = miscell->TimeCon;
(*tl_yychar) = tl_yylex(cnt, hasuform, uform, miscell, tl_yychar);
ptr->rgt = tl_factor(cnt, hasuform, uform, miscell, tl_yychar);
goto simpl;
case NEXT:
ptr = tl_nn(NEXT, ZN, ZN, miscell);
ptr->time = miscell->TimeCon;
(*tl_yychar) = tl_yylex(cnt, hasuform, uform, miscell, tl_yychar);
ptr->lft = tl_factor(cnt, hasuform, uform, miscell, tl_yychar);
goto simpl;
case WEAKNEXT:
ptr = tl_nn(WEAKNEXT, ZN, ZN, miscell);
ptr->time = miscell->TimeCon;
(*tl_yychar) = tl_yylex(cnt, hasuform, uform, miscell, tl_yychar);
ptr->lft = tl_factor(cnt, hasuform, uform, miscell, tl_yychar);
goto simpl;
case EVENTUALLY:
ptr = tl_nn(EVENTUALLY, True, ZN, miscell);
ptr->time = miscell->TimeCon;
(*tl_yychar) = tl_yylex(cnt, hasuform, uform, miscell, tl_yychar);
ptr->rgt = tl_factor(cnt, hasuform, uform, miscell, tl_yychar);
goto simpl;
/* case IMPLIES:
ptr = tl_nn(OR, Not(ptr->lft), ptr->rgt);
goto simpl;
/* case EQUIV:
a = tl_nn(AND,dupnode(ptr->lft),dupnode(ptr->rgt));
b = tl_nn(AND,Not(ptr->lft),Not(ptr->rgt));
ptr = tl_nn(OR, a, b); */
simpl:
if (tl_simp_log_p)
ptr = bin_simpler(ptr,miscell,cnt,uform, tl_yychar);
break;
case PREDICATE:
ptr = miscell->tl_yylval;
(*tl_yychar) = tl_yylex(cnt, hasuform, uform, miscell, tl_yychar);
break;
case TRUE:
case FALSE:
ptr = miscell->tl_yylval;
(*tl_yychar) = tl_yylex(cnt, hasuform, uform, miscell, tl_yychar);
break;
}
if (!ptr) tl_yyerror("expected predicate", cnt, uform, tl_yychar, miscell);
#if 0
printf("factor: ");
tl_explain(ptr->ntyp);
printf("\n");
#endif
return ptr;
}
static int
tl_lex(void)
{ int c;
do {
c = tl_Getchar();
yytext[0] = (char ) c;
yytext[1] = '\0';
if (c <= 0)
{ Token(';');
}
} while (c == ' '); /* '\t' is removed in tl_main.c */
if (islower(c))
{ getword(c, isalnum_);
if (strcmp("true", yytext) == 0)
{ Token(TRUE);
}
if (strcmp("false", yytext) == 0)
{ Token(FALSE);
}
tl_yylval = tl_nn(PREDICATE,ZN,ZN);
tl_yylval->sym = tl_lookup(yytext);
return PREDICATE;
}
if (c == '<')
{ c = tl_Getchar();
if (c == '>')
{
// #ifndef TIMED
// Token(EVENTUALLY);
// #else
c = tl_Getchar();
if (c=='_') {
float* tmp=(float *) malloc(sizeof(float)*2);
tmp=tl_GetIntvl(tmp);
Token_t(EVENTUALLY_I,tmp);
} else {
tl_UnGetchar();
Token(EVENTUALLY);
}
// #endif
}
if (c != '-')
{ tl_UnGetchar();
// #ifdef TIMED
tl_yyerror("expected '<>' or '<->' or '<>_' for -DTIMED flag");
// #else
// tl_yyerror("expected '<>' or '<->' without DTIMED flag");
// #endif
}
c = tl_Getchar();
if (c == '>')
{ Token(EQUIV);
}
tl_UnGetchar();
tl_yyerror("expected '<->'");
}
if (c == '[')
{ c = tl_Getchar();
if (c == ']')
{
// #ifndef TIMED
// Token(ALWAYS);
// #else
c = tl_Getchar();
if (c=='_') {
float* tmp=(float *)malloc(sizeof(float)*2);
tmp=tl_GetIntvl(tmp);
Token_t(ALWAYS_I,tmp);
} else {
tl_UnGetchar();
Token(ALWAYS);
}
// #endif
}else {
tl_UnGetchar();
tl_yyerror("expected '[]' or '[]_'");
}
}
if (c == 'U')
{
#ifndef TIMED
Token(U_OPER);
#else
c = tl_Getchar();
if (c=='_') {
float* tmp=malloc(sizeof(float)*2);
tmp=tl_GetIntvl(tmp);
Token_t(U_I,tmp);
} else {
tl_UnGetchar();
Token(U_OPER);
}
#endif
}
switch (c) {
case '/' : c = follow('\\', AND, '/'); break;
case '\\': c = follow('/', OR, '\\'); break;
case '&' : c = follow('&', AND, '&'); break;
case '|' : c = follow('|', OR, '|'); break;
// case '[' : c = follow(']', ALWAYS, '['); break;
case '-' : c = follow('>', IMPLIES, '-'); break;
case '!' : c = NOT; break;
// case 'U' : c = U_OPER; break;
case 'V' : c = V_OPER; break;
#ifdef NXT
case 'X' : c = NEXT; break;
#endif
default : break;
}
Token(c);
}
static int
tl_lex(void)
{ int c;
do {
c = tl_Getchar();
yytext[0] = (char ) c;
yytext[1] = '\0';
if (c <= 0)
{ Token(';');
}
} while (c == ' '); /* '\t' is removed in tl_main.c */
if (c == '{' || c == '(') /* new 6.0.0 */
{ if (is_predicate(c))
{ read_upto_closing(c);
tl_yylval = tl_nn(PREDICATE,ZN,ZN);
if (!tl_yylval)
{ fatal("unexpected error 4", (char *) 0);
}
tl_yylval->sym = tl_lookup(yytext);
return PREDICATE;
} }
if (c == '}')
{ tl_yyerror("unexpected '}'");
}
if (islower(c))
{ tl_getword(c, isalnum_);
if (strcmp("true", yytext) == 0)
{ Token(TRUE);
}
if (strcmp("false", yytext) == 0)
{ Token(FALSE);
}
if (strcmp("always", yytext) == 0)
{ Token(ALWAYS);
}
if (strcmp("eventually", yytext) == 0)
{ Token(EVENTUALLY);
}
if (strcmp("until", yytext) == 0)
{ Token(U_OPER);
}
#ifdef NXT
if (strcmp("next", yytext) == 0)
{ Token(NEXT);
}
#endif
if (strcmp("c_expr", yytext) == 0)
{ Token(CEXPR);
}
if (strcmp("not", yytext) == 0)
{ Token(NOT);
}
tl_yylval = tl_nn(PREDICATE,ZN,ZN);
if (!tl_yylval)
{ fatal("unexpected error 5", (char *) 0);
}
tl_yylval->sym = tl_lookup(yytext);
return PREDICATE;
}
if (c == '<')
{ c = tl_Getchar();
if (c == '>')
{ Token(EVENTUALLY);
}
if (c != '-')
{ tl_UnGetchar();
tl_yyerror("expected '<>' or '<->'");
}
c = tl_Getchar();
if (c == '>')
{ Token(EQUIV);
}
tl_UnGetchar();
tl_yyerror("expected '<->'");
}
switch (c) {
case '/' : c = tl_follow('\\', AND, '/'); break;
case '\\': c = tl_follow('/', OR, '\\'); break;
case '&' : c = tl_follow('&', AND, '&'); break;
case '|' : c = tl_follow('|', OR, '|'); break;
case '[' : c = tl_follow(']', ALWAYS, '['); break;
case '-' : c = tl_follow('>', IMPLIES, '-'); break;
case '!' : c = NOT; break;
case 'U' : c = U_OPER; break;
case 'V' : c = V_OPER; break;
#ifdef NXT
case 'X' : c = NEXT; break;
#endif
default : break;
}
Token(c);
}
static int tl_lex(int *cnt, size_t hasuform, char *uform, Miscellaneous *miscell, int *tl_yychar)
{
int c,ii;
do {
c = tl_Getchar(cnt, hasuform, uform);
miscell->yytext[0] = (char ) c;
miscell->yytext[1] = '\0';
if (c <= 0)
{ Token(';');
}
} while (c == ' '); /* '\t' is removed in tl_main.c */
/* get the truth constants true and false and predicates */
if (islower(c))
{ getword(c, isalnum_,cnt, hasuform, uform, miscell);
if (strcmp("true", miscell->yytext) == 0)
{ Token(TRUE);
}
if (strcmp("false", miscell->yytext) == 0)
{ Token(FALSE);
}
miscell->tl_yylval = tl_nn(PREDICATE,ZN,ZN,miscell);
miscell->type_temp = PREDICATE;
miscell->tl_yylval->sym = tl_lookup(miscell->yytext, miscell);
/* match predicate index*/
for(ii = 0; ii < miscell->dp_taliro_param.nPred; ii++)
{
if(miscell->predMap[ii].str != NULL)
{
if(strcmp(miscell->tl_yylval->sym->name, miscell->predMap[ii].str)==0)
{
if(miscell->parMap[ii].str == NULL){
miscell->pList.pindex[ii] = PRED;
}else{
miscell->pList.pindex[ii] = PREDPAR;
}
}
}
}
return PREDICATE;
}
/* get temporal operators */
if (c == '<')
{
c = tl_Getchar(cnt, hasuform, uform);
if (c == '>')
{
miscell->tl_yylval = tl_nn(EVENTUALLY,ZN,ZN,miscell);
miscell->type_temp = EVENTUALLY;
mtl_con(cnt, hasuform, uform, miscell,tl_yychar);
return EVENTUALLY;
}
if (c != '-')
{
tl_UnGetchar(cnt);
tl_yyerror("expected '<>' or '<->'", cnt, uform, tl_yychar, miscell);
}
c = tl_Getchar(cnt, hasuform, uform);
if (c == '>')
{
Token(EQUIV);
}
tl_UnGetchar(cnt);
tl_yyerror("expected '<->'", cnt, uform, tl_yychar, miscell);
}
switch (c)
{
case '/' :
c = follow('\\', AND, '/', cnt, hasuform, uform, tl_yychar, miscell);
break;
case '\\':
c = follow('/', OR, '\\', cnt, hasuform, uform, tl_yychar, miscell);
break;
case '&' :
c = follow('&', AND, '&', cnt, hasuform, uform, tl_yychar, miscell);
break;
case '|' :
c = follow('|', OR, '|', cnt, hasuform, uform, tl_yychar, miscell);
break;
case '[' :
c = mtl_follow(']', ALWAYS, '[', cnt, hasuform, uform, miscell, tl_yychar);
break;
case '-' :
c = follow('>', IMPLIES, '-', cnt, hasuform, uform, tl_yychar, miscell);
break;
case '!' :
c = NOT;
break;
case 'U' :
miscell->type_temp = U_OPER;
mtl_con(cnt, hasuform, uform, miscell,tl_yychar);
c = U_OPER;
break;
case 'R' :
miscell->type_temp = V_OPER;
mtl_con(cnt, hasuform, uform, miscell,tl_yychar);
c = V_OPER;
break;
case 'X' :
miscell->type_temp = NEXT;
mtl_con(cnt, hasuform, uform, miscell,tl_yychar);
c = NEXT;
break;
case 'W' :
miscell->type_temp = WEAKNEXT;
mtl_con(cnt, hasuform, uform, miscell, tl_yychar);
c = WEAKNEXT;
break;
default : break;
}
Token(c);
}
static Node *tl_factor(void)
{
Node *ptr = ZN;
switch (tl_yychar)
{
case '(':
ptr = tl_formula();
if (tl_yychar != ')')
tl_yyerror("expected ')'");
tl_yychar = tl_yylex();
goto simpl;
case NOT:
ptr = tl_yylval;
tl_yychar = tl_yylex();
ptr->lft = tl_factor();
ptr = push_negation(ptr);
goto simpl;
case ALWAYS:
ptr = tl_nn(V_OPER, False, ptr);
ptr->time = TimeCon;
tl_yychar = tl_yylex();
ptr->rgt = tl_factor();
if(tl_simp_log)
{ /* must be modified! */
if (ptr->ntyp == V_OPER)
{
if (ptr->lft->ntyp == FALSE)
break; /* [][]p = []p */
ptr = ptr->rgt; /* [] (p V q) = [] q */
}
}
goto simpl;
case NEXT:
ptr = tl_nn(NEXT, ZN, ZN);
ptr->time = TimeCon;
tl_yychar = tl_yylex();
ptr->lft = tl_factor();
goto simpl;
case WEAKNEXT:
ptr = tl_nn(WEAKNEXT, ZN, ZN);
ptr->time = TimeCon;
tl_yychar = tl_yylex();
ptr->lft = tl_factor();
goto simpl;
case EVENTUALLY:
ptr = tl_nn(U_OPER, True, ZN);
ptr->time = TimeCon;
tl_yychar = tl_yylex();
ptr->rgt = tl_factor();
if(tl_simp_log)
{ /* this must be modified */
if (ptr->ntyp == U_OPER && ptr->lft->ntyp == TRUE)
break; /* <><>p = <>p */
if (ptr->ntyp == U_OPER)
{ /* <> (p U q) = <> q */
ptr = ptr->rgt;
/* fall thru */
}
}
/* goto simpl;
case IMPLIES:
ptr = tl_nn(OR, Not(ptr->lft), ptr->rgt);
goto simpl;
case EQUIV:
a = tl_nn(AND,dupnode(ptr->lft),dupnode(ptr->rgt));
b = tl_nn(AND,Not(ptr->lft),Not(ptr->rgt));
ptr = tl_nn(OR, a, b); */
simpl:
if (tl_simp_log)
ptr = bin_simpler(ptr);
break;
case PREDICATE:
ptr = tl_yylval;
tl_yychar = tl_yylex();
break;
case TRUE:
case FALSE:
ptr = tl_yylval;
tl_yychar = tl_yylex();
break;
}
if (!ptr) tl_yyerror("expected predicate");
#if 0
printf("factor: ");
tl_explain(ptr->ntyp);
printf("\n");
#endif
return ptr;
}
