static void La_HuelleFil(LIT x)
/* Berechnet Huelle, DeltaN, DeltaK und NeuK. */
/* (Im Falle von BAUMRES auch EinerKl.) */
{
StapeleintragFZ sp; /* Stapelzeiger auf das naechste freie Element in HF */
StapeleintragFZ p;
if (++Runde == 0)
{
NullsetzenRK(); NullsetzenRL();
Runde = 1;
}
DN = & (DeltaN[Eps][Schalter]); HF = Huelle[Eps][Schalter];
DKF = DeltaK[Eps][Schalter]; NK = NeuK[Eps][Schalter];
#ifndef BAUMRES
HF[0] = x;
#else
HF -> l = x;
#endif
sp = HF + 1;
setzenRundeL(x);
p = HF;
{
unsigned int i;
for (i = 2; i <= aktP; i++)
DKF[i] = NK[i] = 0;
}
do
{
sp = La_belegeFil(x, sp);
p++;
if (sp > p) /* noch 1-Kl. zu eliminieren? */
#ifndef BAUMRES
x = *p;
#else
x = p -> l;
#endif
else
{
*DN = p - HF;
return;
}
}
__inline__ static StapeleintragFZ La_belegeFil(LIT x, StapeleintragFZ sp)
/* Fuehrt x -> 0 durch (bzgl. letzteRK, letzteRL und LaLaenK), */
/* schreibt neu entstehende 1-Klauseln nach HF (mit Eintrag in letzteRL), */
/* wobei sp erhoeht wird, und aktualisiert DKF und NK. */
/* Vor.: Es entsteht nicht die leere Klausel. */
/* Im Falle von BAUMRES wird auch EK aktualisiert. */
/* Rueckgabewert ist der neue Wert von sp. */
{
LITV y, z;
LIT kx, lz, klz;
KLN kn; KLL p;
/* Durchlaufe alle x-Vorkommen und kuerze die aktiven Klauseln */
for (y = erstesVork(x); echtesVork(y, x); y = naechstesVork(y))
{
if (RundeK( kn = KlnVk(y) ) != Runde) /* Klausel von y noch nicht angefasst? */
{
if (Laenge(kn) == 2) /* 2-Klausel? */
{
if (RundeL(klz = Komp(LitVk(naechstesVorkK(y)))) != Runde)
/* 1-Kl-Elim. nicht schon * vorgemerkt? */
{
setzenRundeL(klz);
#ifndef BAUMRES
*(sp++) = klz;
#else
sp -> l = klz;
(sp++) -> k = kn;
#endif
}
}
else /* >= 3-Klausel */
{
setzenRundeK(kn);
p = Laenge(kn);
ZuwLaLaenge(kn, p-1);
DKF[p-1]--;
DKF[p]++;
NK[p-1]++;
}
}
else /* Klausel schon angefasst */
{
if ((p = LaLaenge(kn)) != 0) /* Klausel noch nicht erfuellt? */
{
if (p == 2) /* 2-Klausel? */
{
for (z = naechstesVorkK(y); ; z = naechstesVorkK(z)) /* Suche zweites Literal */
if (RundeL(lz = LitVk(z)) != Runde) /* z nicht auf 0 gesetzt? */
break;
if (RundeL(klz = Komp(lz)) != Runde) /* 1-Kl-Elim. nicht schon vorgemerkt? */
{
setzenRundeL(klz);
#ifndef BAUMRES
*(sp++) = klz;
#else
sp -> l = klz;
(sp++) -> k = kn;
#endif
}
}
else /* >= 3-Klausel */
{
DKF[ M1LaLaenge(kn) ]--;
DKF[p]++;
NK[p-1]++;
NK[p]--;
}
}
}
}
/* Durchlaufen der Komp(x)-Vorkommen und eliminiere alle noch aktiven Klauseln */
for (y = erstesVork(kx = Komp(x)); echtesVork(y, kx); y = naechstesVork(y))
if (RundeK( kn = KlnVk(y) ) != Runde) /* Klausel nicht schon angefasst? */
{
setzenRundeK(kn);
DKF[Laenge(kn)]++;
ZuwLaLaenge(kn, 0);
}
else /* Klausel schon angefasst */
{
if ( (p = LaLaenge(kn)) != 0) /* Klausel noch nicht erfuellt? */
{
DKF[p]++;
NK[p]--;
ZuwLaLaenge(kn, 0);
}
}
return sp;
}
__inline__ static StapeleintragFZ La_belegeFil(const LIT x, StapeleintragFZ sp) {
/* Fuehrt x -> 0 durch (bzgl. letzteRK, letzteRL und LaLaenK), */
/* schreibt neu entstehende 1-Klauseln nach HF (mit Eintrag in letzteRL), */
/* wobei sp erhoeht wird, und aktualisiert DKF und NK. */
/* Vor.: Es entsteht nicht die leere Klausel. */
/* Im Falle von BAUMRES wird auch EK aktualisiert. */
/* Rueckgabewert ist der neue Wert von sp. */
/* Durchlaufe alle x-Vorkommen und kuerze die aktiven Klauseln: */
for (LITV y = erstesVork(x); echtesVork(y, x); y = naechstesVork(y)) {
const KLN kn = KlnVk(y);
if (RundeK(kn) != Runde) {
/* Klausel von y noch nicht angefasst? */
if (Laenge(kn) == 2) { /* 2-Klausel? */
const LIT klz = Komp(LitVk(naechstesVorkK(y)));
if (RundeL(klz) != Runde) {
/* 1-Kl-Elim. nicht schon vorgemerkt? */
setzenRundeL(klz);
#ifndef BAUMRES
*(sp++) = klz;
#else
sp -> l = klz;
(sp++) -> k = kn;
#endif
}
}
else { /* >= 3-Klausel */
setzenRundeK(kn);
const KLL p = Laenge(kn);
ZuwLaLaenge(kn, p-1);
--DKF[p-1];
++DKF[p];
++NK[p-1];
}
}
else { /* Klausel schon angefasst */
const KLL p = LaLaenge(kn);
if (p != 0) { /* Klausel noch nicht erfuellt? */
if (p == 2) { /* 2-Klausel? */
LIT lz; // the second literal
for (LITV z = naechstesVorkK(y); RundeL(lz=LitVk(z)) == Runde; z = naechstesVorkK(z));
const LIT klz = Komp(lz);
if (RundeL(klz) != Runde) { /* 1-Kl-Elim. nicht schon vorgemerkt? */
setzenRundeL(klz);
#ifndef BAUMRES
*(sp++) = klz;
#else
sp -> l = klz;
(sp++) -> k = kn;
#endif
}
}
else { /* >= 3-Klausel */
--DKF[ M1LaLaenge(kn) ];
++DKF[p];
++NK[p-1];
--NK[p];
}
}
}
}
/* Durchlaufen der Komp(x)-Vorkommen und eliminiere alle noch aktiven Klauseln */
const LIT kx = Komp(x);
for (LITV y = erstesVork(kx); echtesVork(y, kx); y = naechstesVork(y)) {
const KLN kn = KlnVk(y);
if (RundeK(kn) != Runde) { /* Klausel nicht schon angefasst? */
setzenRundeK(kn);
++DKF[Laenge(kn)];
ZuwLaLaenge(kn, 0);
}
else { /* Klausel schon angefasst */
const KLL p = LaLaenge(kn);
if (p != 0) { /* Klausel noch nicht erfuellt? */
++DKF[p];
--NK[p];
ZuwLaLaenge(kn, 0);
}
}
}
return sp;
}