//加载配置
VOID CInitParameter::LoadInitParameter()
{
//重置参数
InitParameter();
//获取路径
TCHAR szWorkDir[MAX_PATH]=TEXT("");
CWHService::GetWorkDirectory(szWorkDir,CountArray(szWorkDir));
//构造路径
TCHAR szIniFile[MAX_PATH]=TEXT("");
_sntprintf(szIniFile,CountArray(szIniFile),TEXT("%s\\ServerParameter.ini"),szWorkDir);
//读取配置
CWHIniData IniData;
IniData.SetIniFilePath(szIniFile);
//读取配置
IniData.ReadEncryptString(TEXT("ServerInfo"),TEXT("ServiceName"),NULL,m_szServerName,CountArray(m_szServerName));
IniData.ReadEncryptString(TEXT("ServerInfo"),TEXT("ServiceAddr"),NULL,m_ServiceAddress.szAddress,CountArray(m_ServiceAddress.szAddress));
//协调信息
m_wCorrespondPort=IniData.ReadInt(TEXT("Correspond"),TEXT("ServicePort"),m_wCorrespondPort);
IniData.ReadEncryptString(TEXT("ServerInfo"),TEXT("CorrespondAddr"),NULL,m_CorrespondAddress.szAddress,CountArray(m_CorrespondAddress.szAddress));
//连接信息
m_TreasureDBParameter.wDataBasePort=(WORD)IniData.ReadInt(TEXT("TreasureDB"),TEXT("DBPort"),1433);
IniData.ReadEncryptString(TEXT("TreasureDB"),TEXT("DBAddr"),NULL,m_TreasureDBParameter.szDataBaseAddr,CountArray(m_TreasureDBParameter.szDataBaseAddr));
IniData.ReadEncryptString(TEXT("TreasureDB"),TEXT("DBUser"),NULL,m_TreasureDBParameter.szDataBaseUser,CountArray(m_TreasureDBParameter.szDataBaseUser));
IniData.ReadEncryptString(TEXT("TreasureDB"),TEXT("DBPass"),NULL,m_TreasureDBParameter.szDataBasePass,CountArray(m_TreasureDBParameter.szDataBasePass));
IniData.ReadEncryptString(TEXT("TreasureDB"),TEXT("DBName"),szTreasureDB,m_TreasureDBParameter.szDataBaseName,CountArray(m_TreasureDBParameter.szDataBaseName));
//连接信息
m_PlatformDBParameter.wDataBasePort=(WORD)IniData.ReadInt(TEXT("PlatformDB"),TEXT("DBPort"),1433);
IniData.ReadEncryptString(TEXT("PlatformDB"),TEXT("DBAddr"),NULL,m_PlatformDBParameter.szDataBaseAddr,CountArray(m_PlatformDBParameter.szDataBaseAddr));
IniData.ReadEncryptString(TEXT("PlatformDB"),TEXT("DBUser"),NULL,m_PlatformDBParameter.szDataBaseUser,CountArray(m_PlatformDBParameter.szDataBaseUser));
IniData.ReadEncryptString(TEXT("PlatformDB"),TEXT("DBPass"),NULL,m_PlatformDBParameter.szDataBasePass,CountArray(m_PlatformDBParameter.szDataBasePass));
IniData.ReadEncryptString(TEXT("PlatformDB"),TEXT("DBName"),szPlatformDB,m_PlatformDBParameter.szDataBaseName,CountArray(m_PlatformDBParameter.szDataBaseName));
return;
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
glutInitWindowPosition(100,100);
glutInitWindowSize(width,height);
glutCreateWindow("Display Test");
atexit (freeData);
InitParameter();
generateData();
InitGL();
glutDisplayFunc(renderScene);
glutIdleFunc(renderScene);
glutReshapeFunc(changeSize);
glutMainLoop();
return(0);
}
TEIN Einlesen(FILE *fp, unsigned int G)
{
char c; unsigned int v; VZ e;
P = P0 = N = N0 = K = K0 = L = L0 = 0;
if (G == 0)
return Sat;
{
unsigned int trivSchranke;
trivSchranke = (unsigned int) ceil(G / 2.0); /* laesst Spiel von +1 zu */
if (Schranken && (MAXN < trivSchranke))
{
maxn = MAXN;
M = Lastfaktor * maxn; /* Groesse der Hashtabelle */
unsichermaxn = true;
}
else
{
maxn = trivSchranke;
unsichermaxn = false;
M = trivSchranke;
if (M % 127 == 0)
M++;
}
if (Schranken && (MAXL < trivSchranke))
{
maxl = MAXL;
unsichermaxl = true;
}
else
{
maxl = trivSchranke;
unsichermaxl = false;
}
if (Schranken && (MAXK < trivSchranke))
{
maxk = MAXK;
unsichermaxk = true;
}
else
{
maxk = trivSchranke;
unsichermaxk = false;
}
maxlk = maxl + maxk;
}
Hashtabelle = (unsigned int *) xmalloc(M * sizeof(unsigned int));
aktKlauselAnfang = aktfreies = LitTab = (int *) xmalloc(maxlk * sizeof(int));
freiSymbole = Eingabesymbole = Eingabesymbole0 = (char *) xmalloc(G * sizeof(char));
VarTab = (VarSym *) xmalloc((maxn + 1) * sizeof(VarSym));
memset((void *) Hashtabelle, 0, M * sizeof(unsigned int));
/* 1. Phase: Berechnung von LitTab und VarTab sowie von */
/* P, K, L und P0, N0, K0, L0. */
/* P0, N0, K0, L0 sind hierbei die urspuenglichen Groessen, */
/* waehrend P, K, L die Streichung von tautologischen Klauseln */
/* und Mehrfachvorkommen von Literalen in Klauseln beruecksichtigen. */
/* Format von LitTab: */
/* Variablen sind von 1 ab durchnumeriert, das Komplement von v ist -v, */
/* und Klauselenden werden durch 0 markiert. */
leereKlausel = globalTautologie = Tautologie = EinerKlausel = false;
aktp = aktp0 = 0;
c = getc(fp);
switch (Standard) {
case 1 : goto S1;
case 2 : goto S2;
case 3 : goto S3;
case 4 : goto S4;
}
S1:
ZustandS11 :
if (c == EOF)
goto Phase2;
else if (isspace(c))
{
c = getc(fp); goto ZustandS11;
}
else if (Kommzeichen(c))
{
c = getc(fp); goto ZustandS12;
}
else if (Variablenanfang(c))
{
*(freiSymbole++) = c;
e = Pos; Tautologie = false;
aktp0 = aktp = 0;
c = getc(fp); goto ZustandS15;
}
else if (Negzeichen(c))
{
e = Neg; Tautologie = false;
aktp0 = aktp = 0;
c = getc(fp); goto ZustandS14;
}
else
{
if (c == '0')
fprintf(stderr, "%s\n", Meldung(50));
else
fprintf(stderr, "%s\n", Meldung(8));
Fehlerumgebung(fp, c);
return Fehler;
}
ZustandS12 :
if (c == EOF)
{
fprintf(stderr, "%s\n", Meldung (9));
return Fehler;
}
else if (c == '\n')
{
c = getc(fp); goto ZustandS11;
}
else
{
c = getc(fp); goto ZustandS12;
}
ZustandS14 :
if (isspace(c))
{
c = getc(fp); goto ZustandS14;
}
else if (Variablenanfang(c))
{
*(freiSymbole++) = c;
c = getc(fp); goto ZustandS15;
}
else
{
if (c == EOF)
fprintf(stderr, "%s\n", Meldung(14));
else
{
fprintf(stderr, "%s\n", Meldung(13));
Fehlerumgebung(fp, c);
}
return Fehler;
}
ZustandS15 :
if (isspace(c))
{
*(freiSymbole++) = '\0';
v = eintragen();
if (v == 0)
{
fprintf(stderr, "%s %6d\n", Meldung(35), maxn);
return Fehler;
}
if (! uebernehmenLiteral((e == Pos) ? (int) v : - (int) v))
{
fprintf(stderr, "%s %7d\n", Meldung(38), maxl);
return Fehler;
}
c = getc(fp); goto ZustandS16;
}
else if (isalnum(c))
{
*(freiSymbole++) = c;
c = getc(fp); goto ZustandS15;
}
else
{
if (c == EOF)
fprintf(stderr, "%s\n", Meldung(14));
else
{
fprintf(stderr, "%s\n", Meldung(8));
Fehlerumgebung(fp, c);
}
return Fehler;
}
ZustandS16 :
if (c == '0')
{
if (! uebernehmenKlausel())
{
fprintf(stderr, "%s %6d\n", Meldung(41), maxk);
return Fehler;
}
c = getc(fp); goto ZustandS17;
}
else if (isspace(c))
{
c = getc(fp); goto ZustandS16;
}
else if (Variablenanfang(c))
{
*(freiSymbole++) = c;
e = Pos;
c = getc(fp); goto ZustandS15;
}
else if (Negzeichen(c))
{
e = Neg;
c = getc(fp); goto ZustandS14;
}
else
{
if (c == EOF)
fprintf(stderr, "%s\n", Meldung(14));
else
{
fprintf(stderr, "%s\n", Meldung(8));
Fehlerumgebung(fp, c);
}
return Fehler;
}
ZustandS17 :
if (c == EOF)
goto Phase2;
else if (isspace(c))
{
c = getc(fp); goto ZustandS11;
}
else
{
fprintf(stderr, "%s\n", Meldung(51));
Fehlerumgebung(fp, c);
return Fehler;
}
/* ---------------------- */
S2:
ZustandS21 :
if (c == EOF)
goto Phase2;
else if (isspace(c))
{
c = getc(fp); goto ZustandS21;
}
else if (Kommzeichen(c))
{
c = getc(fp); goto ZustandS22;
}
else if (Klauselbeginn(c))
{
c = getc(fp); goto ZustandS23;
}
else
{
fprintf(stderr, "%s\n", Meldung(8));
Fehlerumgebung(fp, c);
return Fehler;
}
ZustandS22 :
if (c == EOF)
{
fprintf(stderr, "%s\n", Meldung (9));
return Fehler;
}
else if (c == '\n')
{
c = getc(fp); goto ZustandS21;
}
else
{
c = getc(fp); goto ZustandS22;
}
ZustandS23 :
if (Klauselende(c))
{
leereKlausel = true; K0++; K++;
c = getc(fp); goto ZustandS21;
}
else if (isspace(c))
{
c = getc(fp); goto ZustandS23;
}
else if (isalnum(c))
{
*(freiSymbole++) = c;
e = Pos; Tautologie = false;
aktp0 = aktp = 0;
c = getc(fp); goto ZustandS25;
}
else if (Negzeichen(c))
{
e = Neg; Tautologie = false;
aktp0 = aktp = 0;
c = getc(fp); goto ZustandS24;
}
else
{
if (c == EOF)
fprintf(stderr, "%s\n", Meldung(10));
else
{
fprintf(stderr, "%s\n", Meldung(8));
Fehlerumgebung(fp, c);
}
return Fehler;
}
ZustandS24 :
if (isspace(c))
{
c = getc(fp); goto ZustandS24;
}
else if (isalnum(c))
{
*(freiSymbole++) = c;
c = getc(fp); goto ZustandS25;
}
else
{
if (c == EOF)
fprintf(stderr, "%s\n", Meldung(14));
else
{
fprintf(stderr, "%s\n", Meldung(13));
Fehlerumgebung(fp, c);
}
return Fehler;
}
ZustandS25 :
if (Klauselende(c))
{
*(freiSymbole++) = '\0';
v = eintragen();
if (v == 0)
{
fprintf(stderr, "%s %6d\n", Meldung(35), maxn);
return Fehler;
}
if (! uebernehmenLiteral((e == Pos) ? (int) v : - (int) v))
{
fprintf(stderr, "%s %7d\n", Meldung(38), maxl);
return Fehler;
}
if (! uebernehmenKlausel())
{
fprintf(stderr, "%s %6d\n", Meldung(41), maxk);
return Fehler;
}
c = getc(fp); goto ZustandS21;
}
else if (Sepzeichen(c))
{
*(freiSymbole++) = '\0';
v = eintragen();
if (v == 0)
{
fprintf(stderr, "%s %6d\n", Meldung(35), maxn);
return Fehler;
}
if (! uebernehmenLiteral((e == Pos) ? (int) v : - (int) v))
{
fprintf(stderr, "%s %7d\n", Meldung(38), maxl);
return Fehler;
}
c = getc(fp); goto ZustandS27;
}
else if (isspace(c))
{
*(freiSymbole++) = '\0';
v = eintragen();
if (v == 0)
{
fprintf(stderr, "%s %6d\n", Meldung(35), maxn);
return Fehler;
}
if (! uebernehmenLiteral((e == Pos) ? (int) v : - (int) v))
{
fprintf(stderr, "%s %7d\n", Meldung(38), maxl);
return Fehler;
}
c = getc(fp); goto ZustandS26;
}
else if (isalnum(c))
{
*(freiSymbole++) = c;
c = getc(fp); goto ZustandS25;
}
else
{
if (c == EOF)
fprintf(stderr, "%s\n", Meldung(14));
else
{
fprintf(stderr, "%s\n", Meldung(8));
Fehlerumgebung(fp, c);
}
return Fehler;
}
ZustandS26 :
if (Klauselende(c))
{
if (! uebernehmenKlausel())
{
fprintf(stderr, "%s %6d\n", Meldung(41), maxk);
return Fehler;
}
c = getc(fp); goto ZustandS21;
}
else if (isspace(c))
{
c = getc(fp); goto ZustandS26;
}
else if (Sepzeichen(c))
{
c = getc(fp); goto ZustandS27;
}
else
{
if (c == EOF)
fprintf(stderr, "%s\n", Meldung(14));
else
{
fprintf(stderr, "%s\n", Meldung(8));
Fehlerumgebung(fp, c);
}
return Fehler;
}
ZustandS27 :
if (isspace(c))
{
c = getc(fp); goto ZustandS27;
}
else if (isalnum(c))
{
*(freiSymbole++) = c;
e = Pos;
c = getc(fp); goto ZustandS25;
}
else if (Negzeichen(c))
{
e = Neg;
c = getc(fp); goto ZustandS24;
}
else
{
if (c == EOF)
fprintf(stderr, "%s\n", Meldung(15));
else
{
fprintf(stderr, "%s\n", Meldung(16));
Fehlerumgebung(fp, c);
}
return Fehler;
}
/* ---------------------- */
S3:
ZustandS31 :
if (c == EOF)
goto Phase2;
else if (isspace(c))
{
c = getc(fp); goto ZustandS31;
}
else if (Kommzeichen(c))
{
c = getc(fp); goto ZustandS32;
}
else if (Klauselbeginn(c))
{
c = getc(fp); goto ZustandS33;
}
else
{
fprintf(stderr, "%s\n", Meldung(8));
Fehlerumgebung(fp, c);
return Fehler;
}
ZustandS32 :
if (c == EOF)
{
fprintf(stderr, "%s\n", Meldung (9));
return Fehler;
}
else if (c == '\n')
{
c = getc(fp); goto ZustandS31;
}
else
{
c = getc(fp); goto ZustandS32;
}
ZustandS33 :
if (Klauselende(c))
{
leereKlausel = true; K0++; K++;
c = getc(fp); goto ZustandS31;
}
else if (isspace(c))
{
c = getc(fp); goto ZustandS33;
}
else if (isalnum(c))
{
*(freiSymbole++) = c;
e = Pos; Tautologie = false;
aktp0 = aktp = 0;
c = getc(fp); goto ZustandS35;
}
else if (Negzeichen(c))
{
e = Neg; Tautologie = false;
aktp0 = aktp = 0;
c = getc(fp); goto ZustandS34;
}
else
{
if (c == EOF)
fprintf(stderr, "%s\n", Meldung(10));
else
{
fprintf(stderr, "%s\n", Meldung(8));
Fehlerumgebung(fp, c);
}
return Fehler;
}
ZustandS34 :
if (isspace(c))
{
c = getc(fp); goto ZustandS34;
}
else if (isalnum(c))
{
*(freiSymbole++) = c;
c = getc(fp); goto ZustandS35;
}
else
{
if (c == EOF)
fprintf(stderr, "%s\n", Meldung(14));
else
{
fprintf(stderr, "%s\n", Meldung(13));
Fehlerumgebung(fp, c);
}
return Fehler;
}
ZustandS35 :
if (Klauselende(c))
{
*(freiSymbole++) = '\0';
v = eintragen();
if (v == 0)
{
fprintf(stderr, "%s %6d\n", Meldung(35), maxn);
return Fehler;
}
if (! uebernehmenLiteral((e == Pos) ? (int) v : - (int) v))
{
fprintf(stderr, "%s %7d\n", Meldung(38), maxl);
return Fehler;
}
if (! uebernehmenKlausel())
{
fprintf(stderr, "%s %6d\n", Meldung(41), maxk);
return Fehler;
}
c = getc(fp); goto ZustandS31;
}
else if (isspace(c))
{
*(freiSymbole++) = '\0';
v = eintragen();
if (v == 0)
{
fprintf(stderr, "%s %6d\n", Meldung(35), maxn);
return Fehler;
}
if (! uebernehmenLiteral((e == Pos) ? (int) v : - (int) v))
{
fprintf(stderr, "%s %7d\n", Meldung(38), maxl);
return Fehler;
}
c = getc(fp); goto ZustandS36;
}
else if (isalnum(c))
{
*(freiSymbole++) = c;
c = getc(fp); goto ZustandS35;
}
else
{
if (c == EOF)
fprintf(stderr, "%s\n", Meldung(14));
else
{
fprintf(stderr, "%s\n", Meldung(8));
Fehlerumgebung(fp, c);
}
return Fehler;
}
ZustandS36 :
if (Klauselende(c))
{
if (! uebernehmenKlausel())
{
fprintf(stderr, "%s %6d\n", Meldung(41), maxk);
return Fehler;
}
c = getc(fp); goto ZustandS31;
}
else if (isspace(c))
{
c = getc(fp); goto ZustandS36;
}
else if (isalnum(c))
{
*(freiSymbole++) = c;
e = Pos;
c = getc(fp); goto ZustandS35;
}
else if (Negzeichen(c))
{
e = Neg;
c = getc(fp); goto ZustandS34;
}
else
{
if (c == EOF)
fprintf(stderr, "%s\n", Meldung(14));
else
{
fprintf(stderr, "%s\n", Meldung(8));
Fehlerumgebung(fp, c);
}
return Fehler;
}
/* ---------------------- */
S4:
ZustandS41 :
if (c == EOF)
goto Phase2;
else if (c == '\n')
{
leereKlausel = true; K0++; K++;
c = getc(fp); goto ZustandS41;
}
else if (isspace(c))
{
c = getc(fp); goto ZustandS41;
}
else if (Kommzeichen(c))
{
c = getc(fp); goto ZustandS42;
}
else if (isalnum(c))
{
*(freiSymbole++) = c;
e = Pos; Tautologie = false;
aktp0 = aktp = 0;
c = getc(fp); goto ZustandS45;
}
else if (Negzeichen(c))
{
e = Neg; Tautologie = false;
aktp0 = aktp = 0;
c = getc(fp); goto ZustandS44;
}
else
{
fprintf(stderr, "%s\n", Meldung(8));
Fehlerumgebung(fp, c);
return Fehler;
}
ZustandS42 :
if (c == EOF)
{
fprintf(stderr, "%s\n", Meldung (9));
return Fehler;
}
else if (c == '\n')
{
c = getc(fp); goto ZustandS41;
}
else
{
c = getc(fp); goto ZustandS42;
}
ZustandS44 :
if (isspace(c))
{
c = getc(fp); goto ZustandS44;
}
else if (isalnum(c))
{
*(freiSymbole++) = c;
c = getc(fp); goto ZustandS45;
}
else
{
if (c == EOF)
fprintf(stderr, "%s\n", Meldung(14));
else
{
fprintf(stderr, "%s\n", Meldung(13));
Fehlerumgebung(fp, c);
}
return Fehler;
}
ZustandS45 :
if (c == '\n')
{
*(freiSymbole++) = '\0';
v = eintragen();
if (v == 0)
{
fprintf(stderr, "%s %6d\n", Meldung(35), maxn);
return Fehler;
}
if (! uebernehmenLiteral((e == Pos) ? (int) v : - (int) v))
{
fprintf(stderr, "%s %7d\n", Meldung(38), maxl);
return Fehler;
}
if (! uebernehmenKlausel())
{
fprintf(stderr, "%s %6d\n", Meldung(41), maxk);
return Fehler;
}
c = getc(fp); goto ZustandS41;
}
else if (isspace(c))
{
*(freiSymbole++) = '\0';
v = eintragen();
if (v == 0)
{
fprintf(stderr, "%s %6d\n", Meldung(35), maxn);
return Fehler;
}
if (! uebernehmenLiteral((e == Pos) ? (int) v : - (int) v))
{
fprintf(stderr, "%s %7d\n", Meldung(38), maxl);
return Fehler;
}
c = getc(fp); goto ZustandS46;
}
else if (isalnum(c))
{
*(freiSymbole++) = c;
c = getc(fp); goto ZustandS45;
}
else
{
if (c == EOF)
fprintf(stderr, "%s\n", Meldung(14));
else
{
fprintf(stderr, "%s\n", Meldung(8));
Fehlerumgebung(fp, c);
}
return Fehler;
}
ZustandS46 :
if (c == '\n')
{
if (! uebernehmenKlausel())
{
fprintf(stderr, "%s %6d\n", Meldung(41), maxk);
return Fehler;
}
c = getc(fp); goto ZustandS41;
}
else if (isspace(c))
{
c = getc(fp); goto ZustandS46;
}
else if (isalnum(c))
{
*(freiSymbole++) = c;
e = Pos;
c = getc(fp); goto ZustandS45;
}
else if (Negzeichen(c))
{
e = Neg;
c = getc(fp); goto ZustandS44;
}
else
{
if (c == EOF)
fprintf(stderr, "%s\n", Meldung(14));
else
{
fprintf(stderr, "%s\n", Meldung(8));
Fehlerumgebung(fp, c);
}
return Fehler;
}
/* ------------------------------------ */
/* Nun sind P0, N0, K0, L0 und P, K, L berechnet, und */
/* die Eingabe ist in LitTab abgespeichert (Klauseln */
/* getrennt durch 0). */
Phase2:
free(Hashtabelle); Hashtabelle = NULL;
if (! Belegung)
{
free(VarTab); VarTab = NULL;
free(Eingabesymbole0); Eingabesymbole0 = NULL;
}
if (K == 0)
{
N = 0;
return Sat;
}
N = N0;
if (globalTautologie)
/* es muss N neu berechnet werden */
/* und die neuen Variablennummern neu bestimmt werden */
{
unsigned int m, i;
int l; unsigned int v0, v; VZ e;
N = 0;
Hashtabelle = (unsigned int *) xmalloc((N0 + 1) * sizeof(unsigned int));
memset(Hashtabelle, 0, (N0 + 1) * sizeof(unsigned int));
if (Belegung)
VarTab1 = (unsigned int *) xmalloc((N0 + 1) * sizeof(unsigned int));
for (m = i = 0; m < L; m++, i++)
{
l = LitTab[i];
if (l == 0)
l = LitTab[++i];
if (l > 0)
{
v0 = l; e = Pos;
}
else
{
v0 = -l; e = Neg;
}
v = *(Hashtabelle + v0);
if (v == 0)
{
N++;
v = *(Hashtabelle + v0) = N;
if (Belegung)
VarTab1[N] = v0;
}
LitTab[i] = (e == Pos) ? (int) v : - (int) v;
}
free(Hashtabelle); Hashtabelle = NULL;
}
if (leereKlausel)
return Unsat;
if (EinerKlausel)
{
typedef struct {
int *Anfang;
int *Ende;
bool erfuellt;
} Klauselinfo;
typedef struct Vorkommen {
struct Vorkommen *naechstes;
Klauselinfo *Klausel;
} Randvorkommen;
unsigned int AnzahlAnker = 2 * N + 1;
unsigned int PositionAnker = N;
Randvorkommen *Anfangsvorkommen; Randvorkommen *freiesAnfvork;
Randvorkommen *Endvorkommen; Randvorkommen *freiesEndvork;
Klauselinfo *BeginnKlauseln; Klauselinfo *freieKlausel;
bool *belegt;
int *EinerKlauseln; int *sz;
void *Z; unsigned int k;
int *i;
Klauselinfo *Klausel;
unsigned int aktp;
Z0 = xmalloc( 2 * (AnzahlAnker + K) * sizeof(Randvorkommen) +
K * sizeof(Klauselinfo) +
AnzahlAnker * sizeof(bool) +
N * sizeof(LIT));
Anfangsvorkommen = (Randvorkommen *) Z0; Z = (void *) (Anfangsvorkommen + AnzahlAnker); Anfangsvorkommen += PositionAnker;
freiesAnfvork = (Randvorkommen *) Z; Z = (void *) (freiesAnfvork + K);
Endvorkommen = (Randvorkommen *) Z; Z = (void *) (Endvorkommen + AnzahlAnker); Endvorkommen += PositionAnker;
freiesEndvork = (Randvorkommen *) Z; Z = (void *) (freiesEndvork + K);
BeginnKlauseln = freieKlausel = (Klauselinfo *) Z; Z = (void *) (BeginnKlauseln + K);
belegt = (bool *) Z; Z = (void *) (belegt + AnzahlAnker);
belegt += PositionAnker;
EinerKlauseln = (int *) Z; sz = EinerKlauseln;
if (Belegung)
Pfad0 = (int *) xmalloc(N * sizeof(LIT));
for (v = 1; v <= N; v++)
{
(Anfangsvorkommen + v) -> naechstes = NULL;
(Anfangsvorkommen - (int) v) -> naechstes = NULL;
(Endvorkommen + v) -> naechstes = NULL;
(Endvorkommen - (int) v) -> naechstes = NULL;
*(belegt + v) = false;
*(belegt - (int) v) = false;
}
i = LitTab;
for (k = 0; k < K; ++k) {
const int erstesLit = *i; int letztesLit;
int* const i0 = i;
do
++i;
while (*i != 0);
if (i - i0 == 1) {
if (belegt[erstesLit])
return Unsat;
if (! belegt[-erstesLit]) {
belegt[-erstesLit] = true;
*(sz++) = -erstesLit;
}
}
else {
freiesAnfvork -> naechstes = Anfangsvorkommen[erstesLit].naechstes;
Anfangsvorkommen[erstesLit].naechstes = freiesAnfvork;
freiesAnfvork -> Klausel = freieKlausel;
letztesLit = *(i-1);
freiesEndvork -> naechstes = Endvorkommen[letztesLit].naechstes;
Endvorkommen[letztesLit].naechstes = freiesEndvork;
freiesEndvork -> Klausel = freieKlausel;
freieKlausel -> erfuellt = false;
freieKlausel -> Anfang = i0;
freieKlausel -> Ende = i - 1;
freiesAnfvork++; freiesEndvork++; freieKlausel++;
}
++i;
}
do {
int l;
Randvorkommen *x; Randvorkommen *xn;
l = *(--sz);
if (Belegung)
Pfad0[InitEinerRed++] = l;
else
InitEinerRed++;
for (x = Anfangsvorkommen[l].naechstes; x != NULL; x = xn) {
xn = x -> naechstes;
Klausel = x -> Klausel;
if (Klausel -> erfuellt)
continue;
aktp = 0;
#ifndef NDEBUG
int* i0 = 0;
#else
int* i0;
#endif
for (i = (Klausel -> Anfang) + 1; i != (Klausel -> Ende) + 1; i++) {
if (belegt[-*i]) {
Klausel -> erfuellt = true;
break;
}
if (! belegt[*i]) {
if (++aktp == 1)
i0 = i;
else
break;
}
}
if (Klausel -> erfuellt)
continue;
if (aktp == 0)
return Unsat;
if (aktp == 1) {
assert(i0);
belegt[-*i0] = true;
*(sz++) = -*i0;
Klausel -> erfuellt = true;
}
else {
assert(i0);
const int a = *i0;
x -> naechstes = Anfangsvorkommen[a].naechstes;
Anfangsvorkommen[a].naechstes = x;
Klausel -> Anfang = i0;
}
}
for (x = Endvorkommen[l].naechstes; x != NULL; x = xn) {
xn = x -> naechstes;
Klausel = x -> Klausel;
if (Klausel -> erfuellt)
continue;
aktp = 0;
#ifndef NDEBUG
int* i0 = 0;
#else
int* i0;
#endif
for (i = (Klausel -> Ende) - 1; i != (Klausel -> Anfang) - 1; i--) {
if (belegt[-*i]) {
Klausel -> erfuellt = true;
break;
}
if (! belegt[*i]) {
if (++aktp == 1)
i0 = i;
else
break;
}
}
if (Klausel -> erfuellt)
continue;
if (aktp == 0)
return Unsat;
if (aktp == 1) {
assert(i0);
belegt[-*i0] = true;
*(sz++) = -*i0;
Klausel -> erfuellt = true;
}
else {
assert(i0);
const int a = *i0;
x -> naechstes = Endvorkommen[a].naechstes;
Endvorkommen[a].naechstes = x;
Klausel -> Ende = i0;
}
}
}
while (sz != EinerKlauseln);
Hashtabelle = (unsigned int *) xmalloc((N + 1) * sizeof(unsigned int));
memset(Hashtabelle, 0, (N + 1) * sizeof(unsigned int));
if (Belegung)
VarTab2 = (unsigned int *) xmalloc((N - InitEinerRed + 1) * sizeof(unsigned int));
P = N = K = L = 0;
int* i0 = LitTab;
assert(i0);
for (Klausel = BeginnKlauseln; Klausel != freieKlausel; Klausel++) {
if (Klausel -> erfuellt)
continue;
for (i = Klausel -> Anfang; i != (Klausel -> Ende) + 1; i++)
if (belegt[-*i]) {
Klausel -> erfuellt = true;
break;
}
if (Klausel -> erfuellt)
continue;
aktp = 0;
for (i = Klausel -> Anfang; i != (Klausel -> Ende) + 1; i++)
if (! belegt[*i]) {
unsigned int v0, v; int l; VZ e;
aktp++; l = *i;
if (l > 0) {
v0 = l; e = Pos;
}
else {
v0 = -l; e = Neg;
}
v = *(Hashtabelle + v0);
if (v == 0) {
++N;
v = *(Hashtabelle + v0) = N;
if (Belegung)
VarTab2[N] = v0;
}
*(i0++) = (e == Pos) ? (int) v : - (int) v; L++;
}
if (aktp > P)
P = aktp;
K++;
*(i0++) = 0;
}
free(Hashtabelle); Hashtabelle = NULL;
free(Z0); Z0 = NULL;
if (K == 0)
return Sat;
}
/* Erzeugung aller Vektoren, deren Laenge von */
/* P, N, K oder L abhaengt */
if (nurVorreduktion)
return Norm;
InitParameter();
{
void *Basis;
Basis0 = Basis = xmalloc(BedarfVarLitKlmV() + BedarfBelegungV() + BedarfFilterV() + BedarfReduktionsV() + BedarfAbstandsV()
#ifdef BAUMRES
+ BedarfBaumResV()
#endif
);
#ifdef BAUMRES
Basis = BaumResV(Basis);
/* vor VarLitKlm, da Adresse von aktrelV benoetigt wird */
#endif
Basis = VarLitKlmV(Basis);
Basis = BelegungV(Basis);
Basis = FilterV(Basis);
Basis = ReduktionsV(Basis);
Basis = AbstandsV(Basis);
}
/* Zweite Stufe */
/* Nun wird die Klauselmenge hergestellt, LaenK, aktAnzK belegt, */
/* und aktP, aktN werden initialisiert. */
/* Durchlaufen der Literalvorkommen in LitTab */
/* Belegen der Literalvorkommen und von LaenK, aktAnzK */
{
unsigned int k;
int *j;
j = LitTab;
for (k = 0; k < K; k++)
{
Klauselanfangen();
while (*j != 0)
{
Literaleintragen(*j);
j++;
}
Klauselbeenden();
j++;
}
}
if (Belegung)
{
unsigned int v, vi;
for (v = 1; v <= N; v++)
{
vi = v;
if (VarTab2 != NULL)
vi = VarTab2[vi];
if (VarTab1 != NULL)
vi = VarTab1[vi];
Symboleintragen(v, VarTab[vi]);
}
}
free(LitTab); LitTab = NULL;
free(VarTab2); VarTab2 = NULL;
if (! Belegung)
{
free(VarTab1); VarTab1 = NULL;
free(VarTab); VarTab = NULL;
}
aktP = P; /* Initialisieren von aktP */
aktN = N; /* Initialisieren von aktN */
init2Klauseln = aktAnzK[2];
extern enum Ausgabeformat Format;
if (Format == XML_Format)
for (unsigned int i = 0; i <= P - 2; InitAnzK[i+2] = aktAnzK[i+2], i++);
// i wird von 0 gestartet, um Korrektheit auch im Falle von
// P = std::numeric_limits<unsigned int>::max() zu garantieren
return Norm;
}
void CParser::ParseComment(const char *line)
{
param p;
if(!line) return;
line++;
if(strncasecmp(line,"var",3)==0) {
char *token = SkipSpaces(strtok((char*)(line+3)," :"));
p.type = GetParamType(token);
p.is_const = 0;
p.is_internal = 0;
p.is_output = 0;
p.count = 1;
p.name = SkipSpaces(strtok(NULL," :"));
token = SkipSpaces(strtok(NULL," :"));
if(strstr(token,"$vin")) {
token = SkipSpaces(strtok(NULL," :"));
if(strncasecmp(token,"ATTR",4)==0)
p.index = atoi(token+4);
else
p.index = ConvertInputReg(token);
} else if(strstr(token,"texunit")) {
token = SkipSpaces(strtok(NULL," :"));
p.index = atoi(token);
} else if(token[0]=='c') {
p.is_const = 1;
p.index = atoi(token+2);
token = strtok(NULL," ,");
if(isdigit(*token)) p.count = atoi(token);
} else if(strstr(token,"$vout")) {
p.is_output = 1;
token = SkipSpaces(strtok(NULL," :"));
s32 idx = -1;
if(strncasecmp(token,"ATTR",4)==0)
p.index = atoi(token+4);
else
p.index = ConvertOutputReg(token);
}
else
return;
InitParameter(&p);
m_lParameters.push_back(p);
} else if(strncasecmp(line,"const",5)==0) {
char *token = SkipSpaces(strtok((char*)(line+5)," "));
p.is_const = 1;
p.is_internal = 1;
p.type = PARAM_FLOAT4;
p.count = 1;
InitParameter(&p);
if(token[0]=='c' && token[1]=='[') {
u32 i;
f32 *pVal = p.values[0];
p.index = atoi(token+2);
for(i=0;i<4;i++) {
token = strtok(NULL," =");
if(token)
pVal[i] = (f32)atof(token);
else
pVal[i] = 0.0f;
}
} else
return;
m_lParameters.push_back(p);
}
}
//构造函数
CInitParameter::CInitParameter()
{
InitParameter();
}
CProtocolBase::CProtocolBase()
{
InitParameter();
}