char Konstantenfehler ( void )
{
#ifdef BAUMRES
#ifdef LOKALLERNEN
fprintf(stderr, "%s\n", Meldung(1));
return 1;
#endif
#endif
#ifdef FASTAUTARKIE
#ifndef LOKALLERNEN
fprintf(stderr, "%s\n", Meldung(49));
return 1;
#endif
#endif
if ((Sprache < 0) || (Sprache >= ANZSPRACHEN))
{
fprintf(stderr, "%s %2d\n", Meldung(19), ANZSPRACHEN - 1);
return 1;
}
if ((Standard < 0) || (Sprache > ANZSTANDARDS))
{
fprintf(stderr, "%s %2d\n", Meldung(21), ANZSTANDARDS);
return 1;
}
return 0;
}
void Fehlerumgebung(FILE *fp, char c)
{
long Position;
long Zeile, p, letzteZeile;
Position = ftell(fp);
fprintf(stderr, "%s %2ld, ", Meldung(11), Position);
if (isgraph(c))
{
fprintf(stderr, "%c\n", c);
}
else
fprintf(stderr, "\\%03d\n", c);
rewind(fp);
Zeile = 1; letzteZeile = 0;
for (p = 1; p < Position; p++)
{
c = fgetc(fp);
if (c == '\n')
{
Zeile++;
letzteZeile = p;
}
}
fprintf(stderr, "%s %2ld; %s %2ld\n", Meldung(12), Zeile, Meldung(23), Position - letzteZeile);
return;
}
// *** main()**********************************************
int main(int /*argc*/, char* argv[]) {
try {
cout << "\n*** Demo Opalis-DLL-API ***\n"; FLUSH;
DxjInitializeDLL(); // DLL-Init
if (!Meldung(DxjOpen((PSZ)DECODER, // Decoder laden
(PSZ)argv[0], FALSE))) { // FALSE = sichtbar
cout << "\n<Taste> um die Verbindung aufzubauen"; FLUSH;
getch();
Meldung(DxjConnect()); // Anwahl
Dialog2(); // und Action ...
cout << "n<Taste> um die Verbindung zu beenden"; FLUSH;
getch();
Meldung(DxjDisconnect()); // Tsch�� ...
Meldung(DxjTerminate());
Meldung(DxjClose()); // Decoder freigeben
}
DxjTerminateDLL(); // DLL freigeben
cout << "\n*** OK ***"; FLUSH;
return 0; // ... und weg.
} catch (...) {
return -1;
}
}
void Dialog2() {
// Testkonto Commerzbank - Einzel�berweisung
cout << "\nTestkonto Commerzbank : Einzel�berweisung";
cout << "\nsenden :"; FLUSH;
Senden((PSZ)SENDEUEBERW); // BTX-Talk
ofstream datei(DATEINAME);
if (datei) {
// Formular-Seite Erfassung Einzel-�berweisung
// BLZ ist vorgegeben
// Institut wird automatisch eingef�gt
Senden((PSZ)"123456#^Otto Schubert#^100#^25^");
Senden((PSZ)"Rnr.: 123/95#^vom : 12.01.95#^#^");
// Anzeige zur Pr�fung
Senden((PSZ)"#^");
// Best�tigung mit TAN und PIN
Senden((PSZ)"123456^98765^#^");
cout << "\nSeiteninhalt einlesen\n"; FLUSH;
Meldung(DxjReadText(0, 0, 39, 23, (PSZ)seite, sizeof(seite)));
datei << seite << LF;
// 9 senden Ende # weitere �berweisungen
Senden((PSZ)"9^*9#");
datei.flush();
datei.close();
}
}
void Automatisch_Ankratzen(void)
{
short w=prgconfig.wait_g00;
Meldung("St�ck wird automatisch angefahren.");
Status("Auto Nullpunkt");
Setzte_Stahl(radius+1000,laenge+1000,1);
tool=1;
/* Plan ankratzen */
Ziehe_Gerade(radius+1000,laenge+1000,radius-500,laenge+1000,w,schritt_g00,!checkTasten);
Ziehe_Gerade(radius-500,laenge+1000,radius-500,laenge+50,w,schritt_g00,!checkTasten);
Ziehe_Gerade(radius-500,laenge+100,radius-500,laenge+1000,w,schritt_g00,!checkTasten);
Ziehe_Gerade(radius-500,laenge+1000,radius+1000,laenge+1000,w,schritt_g00,!checkTasten);
/* Seite ankr. */
Ziehe_Gerade(radius+1000,laenge+1000,radius+1000,laenge-500,w,schritt_g00,!checkTasten);
Ziehe_Gerade(radius+1000,laenge-500,radius+50,laenge-500,w,schritt_g00,!checkTasten);
Ziehe_Gerade(radius+50,laenge-500,radius+1000,laenge-500,w,schritt_g00,!checkTasten);
Ziehe_Gerade(radius+1000,laenge-500,radius+1000,laenge+1000,w,schritt_g00,!checkTasten);
/* Zur Ecke fahren */
Ziehe_Gerade(radius+1000,laenge+1000,radius+50,laenge+50,w,schritt_g00,!checkTasten);
Ziehe_Gerade(radius+50,laenge+50,radius+100,laenge+100,w,schritt_g00,!checkTasten);
Koordinaten(radius+100,100);
}
char Manuell_Nullpunkt_festlegen(void)
{
int taste;
Meldung("Bitte w�hlen Sie Ihren Startpunkt: (Ctrl+) Cursortasten & Enter");
Status("Manuell Startpunkt");
zpos=100;
xrad=radius+100;
/* Stahl bewegen */
Setzte_Stahl(xrad,zpos,1);
do{
taste=getch();
if (taste==0) taste=getch();
switch(taste)
{
case 72:/* rauf */
if (xrad>10)
xrad-=10;
break;
case 80:/* runter */
if (xrad<radius+2000)
xrad+=10;
break;
case 77:/* rechts */
if (zpos<6000)
zpos+=10;
break;
case 75:/* links */
if (zpos>-((laenge>6000) ? 6000:laenge))
zpos-=10;
break;
case 115:/* ctrl+links */
if (zpos>-((laenge>5750) ? 5750:laenge))
zpos-=250;
break;
case 116:/* ctrl+rechts */
if (zpos<6000)
zpos+=250;
break;
case 141:/* crtl+rauf */
if (xrad>0)
xrad-=250;
break;
case 145:/* crtl+runter */
if (xrad<radius+2000)
xrad+=250;
} /* von switch taste */
Koordinaten(xrad,zpos);
Setzte_Stahl(xrad,zpos,1);
} while (taste!=27 && taste!=13);
if (taste==27) return 1;
else return 0;
}
char Check_FlagTasten(void)
{
char taste,endprg=0;
char meldung_zwischen[80],
status_zwischen[30];
if (kbhit())
{
taste=(char)getch();
while (kbhit()) getch();
strcpy(meldung_zwischen,meldung_str);
strcpy(status_zwischen,status_str);
switch(taste)
{
case 'm':menue=0; break;
case 'n':{
trace=1;
_settextposition(4,37);
_outtext("Ein");
}break;
case 'f':{
trace=0;
_settextposition(4,37);
_outtext("Aus");
}break;
case 's':{
Meldung("Programmfortsetzung mit 'A' - Abbruch der Simulation mit ESC");
Status("Pause");
do {
taste=(char)getch();
if (taste==27) endprg=1;
} while (taste!='a' && !endprg);
Meldung(meldung_zwischen);
Status(status_zwischen);
}
break;
case 27: endprg=1;
} /* von switch */
} /* von if taste */
return endprg;
}
void *xrealloc(void *ptr, size_t size)
{
register void *value = realloc(ptr, size);
if (value == 0)
{
fprintf(stderr, "%s\n", Meldung(5));
exit(1);
}
return value;
}
void Dialog1() {
// Testkonto Commerzbank - Auszug lesen
cout << "\nTestkonto Commerzbank aufrufen";
cout << "\nsenden :"; FLUSH;
Senden((PSZ)SENDEAUSZUG); // BTX-Talk
ofstream datei(DATEINAME);
if (datei) {
cout << "\nSeite einlesen\n"; FLUSH; // Seite lesen
Meldung(DxjReadText(0, 0, 39, 24,
(PSZ)seite, sizeof(seite)));
datei << seite << LF; // Seite speichern
datei.flush();
datei.close();
}
}
char SucheM30(void)
{
char flag=0;
short z;
for (z=0;z<max_line && !flag;z++)
if (!strcmp(cncprg[z].GM,"M30 ")) flag=1;
if (!flag)
{
Status("Ende wegen Fehler");
Meldung("Endbefehl M30 wurde nicht gefunden oder nicht korrekt eingegeben!");
}
return flag;
}
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;
}
char Execute_G(char *ok,char *esc)
{
char endprg=0,
zw_buf1,buf[20];
int g_wert,
xi_wert,
zk_wert,
flkt_wert,
h_wert,
taste;
short P1x,P1z,P2x,P2z, steigung,
step,Xpos,Zpos,za;
struct dostime_t time;
Status("Simulation");
Meldung("Bearbeite G-Befehl.");
/* eventuell test ob nicht G00 -> dann darf g_wert nicht 0 sein -> Err */
/* Werte feststellen */
g_wert=atoi(cncprg[ip].GM);
strcpy(buf,cncprg[ip].XI);
ElimSpaces(buf);
ElimSpaces(buf);
if (isdigit((int)buf[0]) || buf[0]=='-')
xi_wert=atoi(buf);
else xi_wert=atoi(buf+1);
strcpy(buf,cncprg[ip].ZK);
ElimSpaces(buf);
ElimSpaces(buf);
if (isdigit((int)buf[0]) || buf[0]=='-')
zk_wert=atoi(buf);
else zk_wert=atoi(buf+1);
strcpy(buf,cncprg[ip].FLKT);
ElimSpaces(buf);
ElimSpaces(buf);
if (isdigit((int)buf[0]) || buf[0]=='-')
flkt_wert=atoi(buf);
else flkt_wert=atoi(buf+1);
h_wert=atoi(cncprg[ip].H);
/* G-Befehle verzweigen */
switch(g_wert)
{
/**************** G00 *******************/
case 00:if (cncprg[ip].XI[0]!='I' && cncprg[ip].ZK[0]!='K')
{
if (inkrementell)
{ /* G00 INCR */
endprg=Ziehe_Gerade(xrad,zpos,xrad+xi_wert,zpos+zk_wert,
prgconfig.wait_g00,schritt_g00,checkTasten);
if (endprg) { *ok=1; *esc=1; }
xrad=xrad+xi_wert;
zpos=zpos+zk_wert;
} else
{ /* G00 ABS */
endprg=Ziehe_Gerade(xrad,zpos,(short)(xi_wert/2)+xcorr,zk_wert+zcorr,
prgconfig.wait_g00,schritt_g00,checkTasten);
if (endprg) { *ok=1; *esc=1; }
xrad=(short)(xi_wert/2)+xcorr;
zpos=zk_wert+zcorr;
}
}
else { *ok=0; endprg=1; }
break;
/**************** G01 *******************/
case 01:if (cncprg[ip].XI[0]!='I' && cncprg[ip].ZK[0]!='K')
{
if (inkrementell)
{ /* G01 INCR */
endprg=Ziehe_Gerade(xrad,zpos,xrad+xi_wert,zpos+zk_wert,
prgconfig.wait_g01,schritt_g01,checkTasten);
if (endprg) { *ok=1; *esc=1; }
xrad=xrad+xi_wert;
zpos=zpos+zk_wert;
} else
{ /* G01 ABS */
endprg=Ziehe_Gerade(xrad,zpos,(short)(xi_wert/2)+xcorr,zk_wert+zcorr,
prgconfig.wait_g01,schritt_g01,checkTasten);
if (endprg) { *ok=1; *esc=1; }
xrad=(short)(xi_wert/2)+xcorr;
zpos=zk_wert+zcorr;
}
}
else { *ok=0; endprg=1; }
break;
/**************** G02 *******************/
case 02:if (cncprg[ip].XI[0]!='I' && cncprg[ip].ZK[0]!='K')
{
/* test ob == | != 90 */
if (!strcmp(cncprg[ip+1].GM,"M99 "))
{
/* Mittelpunkt bestimmen */
Xpos=atoi(cncprg[ip+1].XI+1);
Zpos=atoi(cncprg[ip+1].ZK+1);
if (cncprg[ip+1].ZK[0]!='K' || cncprg[ip+1].XI[0]!='I')
{
Meldung("Error in M99-Anweisung!"); Status("Fehler");
getch();
endprg=1; *ok=0;
} else
{
/* Kreisbogen(X1,Z1,X2,Z2,XM,ZM,1=G03 0=G02 */
if (inkrementell)
{
endprg=Ziehe_KreisNO90(xrad,zpos,xrad+xi_wert,zpos+zk_wert,xrad+Xpos,zpos+Zpos,0);
/*xrad=xrad+xi_wert;
zpos=zk_wert;*/
}
else {
endprg=Ziehe_KreisNO90(xrad,zpos,(short)(xi_wert/2),zk_wert,xrad+Xpos,zpos+Zpos,0);
/*xrad=(short)(xi_wert/2);
zpos=zk_wert;*/
}
ip++;
}
}
else
{
/* kreisbogen a=90� */
if (inkrementell)
{ /* G02 INC */
endprg=Ziehe_Kreis02(xrad,zpos,xrad+xi_wert,zpos+zk_wert,
prgconfig.wait_g01);
if (endprg) { *ok=1; *esc=1; }
xrad=xrad+xi_wert;
zpos=zpos+zk_wert;
} else
{ /* G02 ABS */
endprg=Ziehe_Kreis02(xrad,zpos,(short)(xi_wert/2)+xcorr,zk_wert+zcorr,prgconfig.wait_g01);
if (endprg) { *ok=1; *esc=1; }
xrad=(short)(xi_wert/2)+xcorr;
zpos=zk_wert+zcorr;
}
} /* von if ==/!=90 */
} else { *ok=0; endprg=1; } /*von if !I & !K */
break;
/**************** G03 *******************/
case 03:if (cncprg[ip].XI[0]!='I' && cncprg[ip].ZK[0]!='K')
{
/* test ob == | != 90 */
if (!strcmp(cncprg[ip+1].GM,"M99 "))
{
/* Mittelpunkt bestimmen */
Xpos=atoi(cncprg[ip+1].XI+1);
Zpos=atoi(cncprg[ip+1].ZK+1);
if (cncprg[ip+1].ZK[0]!='K' || cncprg[ip+1].XI[0]!='I')
{
Meldung("Error in M99-Anweisung!"); Status("Fehler");
getch();
endprg=1; *ok=0;
} else
{
/* Kreisbogen(X1,Z1,X2,Z2,XM,ZM,1=G03 0=G02 */
if (inkrementell)
endprg=Ziehe_KreisNO90(xrad,zpos,xrad+xi_wert,zpos+zk_wert,xrad+Xpos,zpos+Zpos,1);
else endprg=Ziehe_KreisNO90(xrad,zpos,(short)(xi_wert/2),zk_wert,xrad+Xpos,zpos+Zpos,1);
ip++;
}
}
else
{
/* kreisbogen a=90� */
if (inkrementell)
{ /* G03 INC */
endprg=Ziehe_Kreis03(xrad,zpos,xrad+xi_wert,zpos+zk_wert,
prgconfig.wait_g01);
if (endprg) { *ok=1; *esc=1; }
xrad=xrad+xi_wert;
zpos=zpos+zk_wert;
} else
{ /* G03 ABS */
endprg=Ziehe_Kreis03(xrad,zpos,(short)(xi_wert/2)+xcorr,zk_wert+zcorr,prgconfig.wait_g01);
if (endprg) { *ok=1; *esc=1; }
xrad=(short)(xi_wert/2)+xcorr;
zpos=zk_wert+zcorr;
} /* von inkr | abs */
} /* von if a==90 */
} else { *ok=0; endprg=1; } /*von if !I & !K */
break;
/**************** G04 *******************/
case 4 :/* Verweilzeit */
if (cncprg[ip].XI[0]!='I')
{
za=0;
step=0;
do {
_dos_gettime(&time);
if (kbhit()) taste=getch();
if ((short)time.second!=za) { za=(short)time.second; step++; }
} while (step<(short)(xi_wert/100) && taste!=27);
}
break;
/**************** G21 *******************/
case 21:break; /* rem */
/**************** G25 *******************/
case 25: /* Unterprgr */
if (cncprg[ip].FLKT[0]=='L' && flkt_wert<max_line && sp<4)
{
stack[sp++]=ip;
ip=--flkt_wert;
} else
{
Status("Error!");
Meldung("Fehler im GOSUB-G27-Befehl!");
*ok=0; endprg=1;
}break;
/**************** G26 *******************/
case 26: /* werkzeugwechsel */
if (cncprg[ip].FLKT[0]=='T' && flkt_wert>0 && flkt_wert<=max_tools)
{
_settextposition(3,37);
_outtext(cncprg[ip].FLKT);
_outtext(" ");
Setzte_Stahl(xrad,zpos,(char)flkt_wert);
endprg=Ziehe_Gerade(xrad,zpos,xrad+xi_wert,zpos+zk_wert,
prgconfig.wait_g00,schritt_g00,checkTasten);
xrad=xrad+xi_wert;
zpos=zpos+zk_wert;
xcorr=xi_wert; /* Korrekturwerte des Stahles muessen */
zcorr=zk_wert; /* in Abs. mit einberechnet werden */
} else { *ok=0; endprg=1; }
break;
/**************** G27 *******************/
case 27: /* goto */
if (cncprg[ip].FLKT[0]=='L' && flkt_wert<max_line)
ip=--flkt_wert;
else { *ok=0; endprg=1; }
break;
/**************** G33 *******************/
case 33: /* gewinde schneiden */
if (cncprg[ip].FLKT[0]=='K' && flkt_wert>=2 && flkt_wert<500)
{
steigung=flkt_wert;
if (inkrementell)
{ /* INCR */
endprg=Gewinde(xrad,zpos,zpos+zk_wert,steigung,prgconfig.wait_g01+10000);
if (endprg) { *ok=1; *esc=1; }
zpos=zpos+zk_wert;
} else
{ /* ABS */
endprg=Gewinde(xrad,zpos,zcorr+zk_wert,steigung,prgconfig.wait_g01+10000);
if (endprg) { *ok=1; *esc=1; }
zpos=zk_wert+zcorr;
}
}
else { *ok=0; endprg=1; }
break;
/**************** G78 *******************/
case 78: /* Gewindezyklus */
if (cncprg[ip].FLKT[0]=='K' && flkt_wert>=2 && flkt_wert<500)
{
/* Start & Zielkoord */
P1x=xrad; P1z=zpos;
if (inkrementell)
{
P2x=xrad+xi_wert;
P2z=zpos+zk_wert;
} else {
P2x=(short)(xi_wert/2)+xcorr;
P2z=zk_wert+zcorr;
}
/* Schritt & Steigung */
step=h_wert;
steigung=flkt_wert;
/* Anfahren */
if (step!=0)
if (P1x>P2x)
for (Xpos=P1x;Xpos-step>P2x && !endprg;Xpos-=step)
{
endprg=Ziehe_Gerade(P1x,P1z,Xpos-step,P1z,
prgconfig.wait_g01,schritt_g01,checkTasten);
if (!endprg)
endprg=Gewinde(Xpos-step,P1z,P2z,steigung,prgconfig.wait_g01+10000);
if (!endprg)
endprg=Ziehe_Gerade(xrad,zpos,P1x,P2z,
prgconfig.wait_g00,schritt_g00,checkTasten);
if (!endprg)
endprg=Ziehe_Gerade(P1x,P2z,P1x,P1z,
prgconfig.wait_g00,schritt_g00,checkTasten);
}
else for (Xpos=P1x;Xpos+step<P2x && !endprg;Xpos+=step)
{
endprg=Ziehe_Gerade(P1x,P1z,Xpos+step,P1z,
prgconfig.wait_g01,schritt_g01,checkTasten);
if (!endprg)
endprg=Gewinde(Xpos+step,P1z,P2z,steigung,prgconfig.wait_g01+10000);
if (!endprg)
endprg=Ziehe_Gerade(xrad,zpos,P1x,P2z,
prgconfig.wait_g00,schritt_g00,checkTasten);
if (!endprg)
endprg=Ziehe_Gerade(P1x,P2z,P1x,P1z,
prgconfig.wait_g00,schritt_g00,checkTasten);
}
/* letzter Schritt oder Schritt ohne Aufteilung*/
if (!endprg)
endprg=Ziehe_Gerade(P1x,P1z,P2x,P1z,
prgconfig.wait_g01,schritt_g01,checkTasten);
if (!endprg)
endprg=Gewinde(P2x,P1z,P2z,steigung,prgconfig.wait_g01+20000);
if (!endprg)
endprg=Ziehe_Gerade(xrad,zpos,P1x,P2z,
prgconfig.wait_g01+4000,schritt_g00,checkTasten);
if (!endprg)
endprg=Ziehe_Gerade(P1x,P2z,P1x,P1z,
prgconfig.wait_g00,schritt_g00,checkTasten);
if (endprg) { *ok=1; *esc=1; }
xrad=P1x;
zpos=P1z;
} break;
/**************** G84 *******************/
case 84: /* laengsdrehzyklus */
if (cncprg[ip].XI[0]!='I' && cncprg[ip].ZK[0]!='K')
{
/* Start & Zielkoord */
P1x=xrad; P1z=zpos;
if (inkrementell)
{
P2x=xrad+xi_wert;
P2z=zpos+zk_wert;
} else {
P2x=(short)(xi_wert/2)+xcorr;
P2z=zk_wert+zcorr;
}
/* Schritt */
step=h_wert;
/* Anfahren */
if (step!=0)
if (P1x>P2x)
for (Xpos=P1x;Xpos-step>P2x && !endprg;Xpos-=step)
{
endprg=Ziehe_Gerade(Xpos,P1z,Xpos-step,P1z,
prgconfig.wait_g01,schritt_g01,checkTasten);
if (!endprg)
endprg=Ziehe_Gerade(Xpos-step,P1z,Xpos-step,P2z,
prgconfig.wait_g01,schritt_g01,checkTasten);
if (!endprg)
endprg=Ziehe_Gerade(Xpos-step,P2z,Xpos-step,P1z,
prgconfig.wait_g00,schritt_g00,checkTasten);
}
else for (Xpos=P1x;Xpos+step<P2x && !endprg;Xpos+=step)
{
endprg=Ziehe_Gerade(Xpos,P1z,Xpos+step,P1z,
prgconfig.wait_g01,schritt_g01,checkTasten);
if (!endprg)
endprg=Ziehe_Gerade(Xpos+step,P1z,Xpos+step,P2z,
prgconfig.wait_g01,schritt_g01,checkTasten);
if (!endprg)
endprg=Ziehe_Gerade(Xpos+step,P2z,Xpos+step,P1z,
prgconfig.wait_g00,schritt_g00,checkTasten);
}
else Xpos=P1x; /* von if step!=0 */
/* letzter Schritt */
if (!endprg)
endprg=Ziehe_Gerade(Xpos,P1z,P2x,P1z,
prgconfig.wait_g01,schritt_g01,checkTasten);
if (!endprg)
endprg=Ziehe_Gerade(P2x,P1z,P2x,P2z,
prgconfig.wait_g01,schritt_g01,checkTasten);
if (!endprg)
endprg=Ziehe_Gerade(P2x,P2z,P1x,P2z,
prgconfig.wait_g01,schritt_g01,checkTasten);
if (!endprg)
endprg=Ziehe_Gerade(P1x,P2z,P1x,P1z,
prgconfig.wait_g00,schritt_g00,checkTasten);
if (endprg) { *ok=1; *esc=1; }
xrad=P1x;
zpos=P1z;
} break;
/**************** G86 *******************/
case 86: /* Austechzyklus */
if (cncprg[ip].XI[0]!='I' && cncprg[ip].ZK[0]!='K')
{
/* Start & Zielkoord */
P1x=xrad; P1z=zpos;
if (inkrementell)
{
P2x=xrad+xi_wert;
P2z=zpos+zk_wert;
} else {
P2x=(short)(xi_wert/2)+xcorr;
P2z=zk_wert+zcorr;
}
/* Schritt */
step=h_wert;
za=abs(P1z-P2z);
if (za<step || step<10 || step>999)
*ok=0;
else
{
/* Anfahren */
if (P1z>P2z)
for (Zpos=P1z;Zpos>P2z && !endprg;Zpos-=step)
{
endprg=Ziehe_Gerade(P1x,Zpos,P2x,Zpos,
prgconfig.wait_g01,schritt_g01,checkTasten);
if (!endprg)
endprg=Ziehe_Gerade(P2x,Zpos,P1x,Zpos,
prgconfig.wait_g00,schritt_g00,checkTasten);
if (!endprg)
endprg=Ziehe_Gerade(P1x,Zpos,P1x,Zpos-step,
prgconfig.wait_g00,schritt_g00,checkTasten);
}
else for (Zpos=P1z;Zpos<P2z && !endprg;Zpos+=step)
{
endprg=Ziehe_Gerade(P1x,Zpos,P2x,Zpos,
prgconfig.wait_g01,schritt_g01,checkTasten);
if (!endprg)
endprg=Ziehe_Gerade(P2x,Zpos,P1x,Zpos,
prgconfig.wait_g00,schritt_g00,checkTasten);
if (!endprg)
endprg=Ziehe_Gerade(P1x,Zpos,P1x,Zpos+step,
prgconfig.wait_g00,schritt_g00,checkTasten);
}
/* letzter Schritt */
if (!endprg)
endprg=Ziehe_Gerade(P1x,Zpos,P1x,P2z,
prgconfig.wait_g01,schritt_g01,checkTasten);
if (!endprg)
endprg=Ziehe_Gerade(P1x,P2z,P2x,P2z,
prgconfig.wait_g01,schritt_g01,checkTasten);
if (!endprg)
endprg=Ziehe_Gerade(P2x,P2z,P1x,P2z,
prgconfig.wait_g01,schritt_g01,checkTasten);
if (!endprg)
endprg=Ziehe_Gerade(P1x,P2z,P1x,P1z,
prgconfig.wait_g00,schritt_g00,checkTasten);
if (endprg) { *ok=1; *esc=1; }
}
xrad=P1x;
zpos=P1z;
}break;
/**************** G88 *******************/
case 88: /* plandrehzyklus */
if (cncprg[ip].XI[0]!='I' && cncprg[ip].ZK[0]!='K')
{
/* Start & Zielkoord */
P1x=xrad; P1z=zpos;
if (inkrementell)
{
P2x=xrad+xi_wert;
P2z=zpos+zk_wert;
} else {
P2x=(short)(xi_wert/2)+xcorr;
P2z=zk_wert+zcorr;
}
/* Schritt */
step=h_wert;
/* Anfahren */
if (step!=0)
if (P1z>P2z)
for (Zpos=P1z;Zpos-step>P2z && !endprg;Zpos-=step)
{
endprg=Ziehe_Gerade(P1x,Zpos,P1x,Zpos-step,
prgconfig.wait_g01,schritt_g01,checkTasten);
if (!endprg)
endprg=Ziehe_Gerade(P1x,Zpos-step,P2x,Zpos-step,
prgconfig.wait_g01,schritt_g01,checkTasten);
if (!endprg)
endprg=Ziehe_Gerade(P2x,Zpos-step,P1x,Zpos-step,
prgconfig.wait_g00,schritt_g00,checkTasten);
}
else for (Zpos=P1z;Zpos+step<P2z && !endprg;Zpos+=step)
{
endprg=Ziehe_Gerade(P1x,Zpos,P1x,Zpos+step,
prgconfig.wait_g01,schritt_g01,checkTasten);
if (!endprg)
endprg=Ziehe_Gerade(P1x,Zpos+step,P2x,Zpos+step,
prgconfig.wait_g01,schritt_g01,checkTasten);
if (!endprg)
endprg=Ziehe_Gerade(P2x,Zpos+step,P1x,Zpos+step,
prgconfig.wait_g00,schritt_g00,checkTasten);
}
else Zpos=P1z; /* von if step!=0 */
/* letzter Schritt */
if (!endprg)
endprg=Ziehe_Gerade(P1x,Zpos,P1x,P2z,
prgconfig.wait_g01,schritt_g01,checkTasten);
if (!endprg)
endprg=Ziehe_Gerade(P1x,P2z,P2x,P2z,
prgconfig.wait_g01,schritt_g01,checkTasten);
if (!endprg)
endprg=Ziehe_Gerade(P2x,P2z,P2x,P1z,
prgconfig.wait_g01,schritt_g01,checkTasten);
if (!endprg)
endprg=Ziehe_Gerade(P2x,P1z,P1x,P1z,
prgconfig.wait_g00,schritt_g00,checkTasten);
if (endprg) { *ok=1; *esc=1; }
xrad=P1x;
zpos=P1z;
} break;
/**************** G90 *******************/
case 90:{
/* Absoltut ein : NP = Pos des Drehmeissels */
inkrementell=0;
_settextposition(3,66);
_outtext("ABS");
/* Neuer NP setzten & akt. Koord. anpassen */
NeuerGrNP(xrad,zpos);
xrad=0;
zpos=0;
} break;
/**************** G91 *******************/
case 91:/* Inkrementell ein */
inkrementell=1;
break;
/**************** G92 *******************/
case 92:if (cncprg[ip].XI[0]!='I' && cncprg[ip].ZK[0]!='K')
{
/* Absolut ein : NP = Parameter */
inkrementell=0;
_settextposition(3,66);
_outtext("ABS");
/* Neuer NP setzten & akt. Koord. anpassen */
zw_buf1=tool; /* Werkzeug zwischenspeichern & loeschen */
Setzte_Stahl(0,0,0);
NeuerGrNP(xrad-(short)(xi_wert/2),zpos-zk_wert);
xrad=(short)(xi_wert/2);
zpos=zk_wert;
tool=zw_buf1;
Setzte_Stahl(xrad,zpos,tool);
} else { *ok=0; endprg=1; } /*von if !I & !K */
break;
/**************** G94 *******************/
case 94: break; /* zZ no Action */
/**************** G95 *******************/
case 95: break; /* zZ no Action */
/**************** Error *******************/
default:/* Unbekannter G-Befehl */
{
*ok=0; /* Fehlerflag */
endprg=1; /* Prg-Ende-Flag */
}
}/* von switch m_wert */
/* Returnwert */
if (!*ok && endprg)
{
Status("E-Unterbrechung");
Meldung("G-Befehl in der aktuellen Zeile ist unbekannt oder unkorrekt!");
}
return endprg;
}
char Execute_M(char *ok,char *esc)
{
char endprg=0, arghhhh=*esc,
Mbuffer[6],buf[20];
int m_wert;
int xi_wert,
zk_wert,
flkt_wert,
h_wert;
Status("Simulation");
Meldung("Bearbeite M-Befehl.");
/* G/M umkopieren zwecks Veraenderung */
strcpy(Mbuffer,cncprg[ip].GM);
/* M-Zeichen eliminieren & Wert feststellen */
Mbuffer[0]=' ';
m_wert=atoi(Mbuffer);
strcpy(buf,cncprg[ip].XI);
ElimSpaces(buf);
ElimSpaces(buf);
if (isdigit((int)buf[0]) || buf[0]=='-')
xi_wert=atoi(buf);
else xi_wert=atoi(buf+1);
strcpy(buf,cncprg[ip].ZK);
ElimSpaces(buf);
ElimSpaces(buf);
if (isdigit((int)buf[0]) || buf[0]=='-')
zk_wert=atoi(buf);
else zk_wert=atoi(buf+1);
strcpy(buf,cncprg[ip].FLKT);
ElimSpaces(buf);
ElimSpaces(buf);
if (isdigit((int)buf[0]) || buf[0]=='-')
flkt_wert=atoi(buf);
else flkt_wert=atoi(buf+1);
h_wert=atoi(cncprg[ip].H);
/* M-Befehle verzweigen */
switch(m_wert)
{
/**************** M00 *******************/
case 0:{
Meldung("Taste zur Fortsetzung.");
getch();
Meldung(" ");
} break; /* No Action */
/**************** M01: Pseudo: Stueck neuzeichnen *******************/
case 1:{
DemoText();
Zeichne_stueck();
}break;
/**************** M03 *******************/
case 3:break; /* No Action */
/**************** M05 *******************/
case 5:break; /* No Action */
/**************** M06 *******************/
case 6: /* werkzeugwechsel */
if (cncprg[ip].FLKT[0]=='T' && flkt_wert>0 && flkt_wert<=max_tools)
{
_settextposition(3,37);
_outtext(cncprg[ip].FLKT);
_outtext(" ");
Setzte_Stahl(xrad,zpos,(char)flkt_wert);
endprg=Ziehe_Gerade(xrad,zpos,xrad+xi_wert,zpos+zk_wert,
prgconfig.wait_g00,schritt_g00,checkTasten);
xrad=xrad+xi_wert;
zpos=zpos+zk_wert;
xcorr=xi_wert;
zcorr=zk_wert;
} else { *ok=0; endprg=1; }
break;
/**************** M17 *******************/
case 17:if (sp>0)
{
ip=stack[--sp];
ip++;
} else
{
Meldung("Fehler im RETURN-M17-Befehl: Keine Subroutine!");
Status("Fehler!");
endprg=1; *ok=0;
}break;
/**************** M30 *******************/
case 30:{
Status("M30-Ende");
Meldung(" ");
endprg=1;
} break;
/**************** M98 *******************/
case 98:break; /* No Action */
/**************** M99 *******************/
case 99:{
/* nur in Verbindung mit G02/G03 */
Meldung("Einzelner M99 Befehl gefunden!!");
Status("Fehler!");
endprg=1;
*ok=0;
}
/**************** Error *******************/
default:/* Unbekannter M-Befehl */
{
*ok=0; /* Fehlerflag */
endprg=1; /* Prg-Ende-Flag */
}
}/* von switch m_wert */
/* Returnwert */
if (!*ok && endprg)
{
Status("E-Unterbrechung");
Meldung("M-Befehl in der aktuellen Zeile ist unbekannt oder unkorrekt!");
}
return endprg;
}
void CNCSimulation(void)
{
char esc,ok,prg_ende=0;
char t[20]={"Test Fall Test e"};
if (!Hole_DMuLNG())
{
/* Simulator initialisieren */
Init_Simulator();
SimBildschirmmaske();
if (prgconfig.monitor2)
Init2HGCMon();
/* Benutzer einstellen lassen */
_setvieworg(0,50); /* Zum Ankratzen NP=MaschinenNP */
Automatisch_Ankratzen(); /* Nehmen wir dem Jungen die Arbeit ab.*/
Setzte_Stahl(0,0,0); /* Um Fehler zu vermeiden - Stahl loeschen */
/* Stuecknullpunkt fuer Einstellungen (neuer NP im prg)*/
_setvieworg(Unit2PntX(laenge),50);
grNPx=Unit2PntX(laenge);
grNPy=50;
ZeileAusgabe(0); /* Anzeige der ersten Zeile zur Orientierung */
esc=Manuell_Nullpunkt_festlegen(); /* Stahl auf eigenen Nullpunkt steuern */
if (!esc)
ok=SucheM30();
if (!trace) {
Meldung("Taste zum Programmstart");
Status("Warte");
while (kbhit());
while (!kbhit());
prg_ende=Check_FlagTasten();
}
/* Programm-Hauptscheife */
if (!esc && ok)
for (ip=0;!prg_ende;ip++)
if (ip==max_line)
{
Meldung("Zeilenlimit erreicht - M30 �bersprungen");
Status("Taste!");
prg_ende=1;
} else
{
ZeileAusgabe(ip);
if (trace) {
Meldung("Warte auf Tastendruck...");
Status("Trace-Stop");
while (kbhit()) getch();
while (!kbhit());
prg_ende=Check_FlagTasten();
}
if (!prg_ende)
{
if (cncprg[ip].GM[0]=='M') prg_ende=Execute_M( &ok,&esc);
else prg_ende=Execute_G(&ok,&esc);
}
}
/* test ob noch UP auf Stack */
if (sp!=0 && (!esc || !ok))
{
Meldung("M30 im Unterprogramm gefunden!");
Status("Error!");
}
/* Simulation beendet */
if (esc)
{
Meldung("ESC-Taste bet�tigt - Taste zum Beenden.");
Status("Abbruch durch ESC!");
}
getch(); /* Taste zum ClrScr */
_setvideomode(_TEXTC80);
SYS_CursorOff();
Bildschirmmaske();
}
}
char Ziehe_KreisNO90(short xr1,short zp1,short xr2,short zp2,short xrm,short zpm,char g03g02)
{
double sx=(double)zp1,sy=(double)xr1,
ex=(double)zp2,ey=(double)xr2,
mx=(double)zpm,my=(double)xrm;
double dx,dy,w,cosw,sinw;
double rad1,rad2,stw,endw,step=(double)schritt_g02;
char quadr1,quadr2,endprg=0;
short x,y;
dx=sx-mx;
dy=sy-my;
rad1=sqrt(dx*dx+dy*dy);
cosw=dx/rad1;
sinw=dy/rad1;
stw=arc_wi(sinw,cosw,&quadr1);
dx=ex-mx;
dy=ey-my;
rad2=sqrt(dx*dx+dy*dy);
cosw=dx/rad2;
sinw=dy/rad2;
endw=arc_wi(sinw,cosw,&quadr2);
if (quadr1!=quadr2) { /* Routine zZ noch nicht in Funktion */
Meldung("M99 Quadranten-Fehler!");
Status("Fehler!");
getch();
endprg=1;
}
if (fabs(fabs(rad1)-fabs(rad2))>160)
{
Meldung("M99-0,8mm-Toleranz �berschritten");
Status("Fehler");
getch();
endprg=1; /* Nur zZ */
}
if (!endprg)
{
if (g03g02)
{ /* G02 */
if (endw<stw) stw-=360.0;
for(w=stw;w<endw && !endprg;w+=step)
{
x=(short)(mx+rad1*cos(w*deg));
y=(short)(my+rad1*sin(w*deg));
Setzte_Stahl(y,x,tool);
Koordinaten(y,x);
xrad=y;
zpos=x;
Wait(prgconfig.wait_g01);
endprg=Check_FlagTasten();
}
} else { /* g03 */
if (endw>stw) endw-=360.0;
for(w=stw;w>endw && !endprg;w-=step)
{
x=(short)(mx+rad1*cos(w*deg));
y=(short)(my+rad1*sin(w*deg));
Setzte_Stahl(y,x,tool);
Koordinaten(y,x);
xrad=y;
zpos=x;
Wait(prgconfig.wait_g01);
endprg=Check_FlagTasten();
}
} /* von g03 */
} /* von if !endprg */
if (!endprg)
{
Setzte_Stahl(xr2,zp2,tool);
xrad=xr2;
zpos=zp2;
Koordinaten(xr2,zp2);
}
return endprg;
}
int main(const int argc, const char* const argv[]) {
const char* const Ausgabedatei = "OKs" VERSIONSNUMMER1 "_" VERSIONSNUMMER2 "_" OPTIONENKENNUNG5 OPTIONENKENNUNG6 OPTIONENKENNUNG7 OPTIONENKENNUNG1 OPTIONENKENNUNG2 OPTIONENKENNUNG3 OPTIONENKENNUNG4".res";
const char* const Version = VERSIONSNUMMER1 "." VERSIONSNUMMER2;
#ifdef SYSTIME
EPS = sysconf(_SC_CLK_TCK);
#endif
signal(SIGUSR1, Zustandsanzeige);
signal(SIGINT, Abbruch);
signal(SIGALRM, Abbruch);
if (setjmp(Ausgabepunkt))
goto Ausgabe;
if (Konstantenfehler()) {
fprintf(stderr, "%s\n", Meldung(0));
return 1;
}
if (argc == 1) {
fprintf(stderr, "%s\n", Meldung(3));
return 0;
}
setzenStandard();
for (Argument = 1; Argument < argc; Argument++) {
if (strcmp("--version", argv[Argument]) == 0) {
printf("%s %s; %s %s\n%s: %s, %s\n", Meldung(24), DATUM, Meldung(2), Version, Meldung(6), __DATE__, __TIME__);
printf("%s", Meldung(44));
#ifdef NBAUMRES
printf(" NBAUMRES");
#endif
#ifdef LITTAB
printf(" LITTAB");
#endif
#ifdef SYSTIME
printf(" SYSTIME");
#endif
#ifdef DYNAMISCH
printf(" DYNAMISCH");
#endif
#ifdef DYNAMISCH
printf(" FAKTOR=%.2f", FAKTOR);
#endif
#ifdef LOKALLERNEN
printf(" LOKALLERNEN");
#endif
#ifdef NL2RED
printf(" NL2RED");
#endif
#ifdef FASTAUTARKIE
printf(" FASTAUTARKIE");
#endif
#ifdef KEININLINE
printf(" KEININLINE");
#endif
#ifdef OUTPUTTREEDATAXML
printf(" OUTPUTTREEDATAXML");
#endif
printf(" STANDARD=%1d", STANDARD);
printf("\n");
printf("%s %s\n", Meldung(45), Abstandsname);
printf("%s %s\n", Meldung(46), Projektionsname);
}
else if (strcmp("--author", argv[Argument]) == 0)
printf("%s\n", Meldung(25));
else if (strcmp("--help", argv[Argument]) == 0)
printf("%s\n", Meldung(26));
else if (strcmp("-O", argv[Argument]) == 0)
Belegung = ! Belegung;
else if (strcmp("-F", argv[Argument]) == 0)
Dateiausgabe = ! Dateiausgabe;
else if (strcmp("-M", argv[Argument]) == 0)
Monitor = ! Monitor;
else if (strcmp("-P", argv[Argument]) == 0)
nurVorreduktion = ! nurVorreduktion;
else if (strcmp("-R", argv[Argument]) == 0)
spezRueckgabe = ! spezRueckgabe;
else if (strcmp("-B", argv[Argument]) == 0)
Schranken = ! Schranken;
else if (strcmp("--info", argv[Argument]) == 0)
printf("%s\n%s\n", Meldung(47), Meldung(48));
else if (strcmp("-RA", argv[Argument]) == 0)
randomisiert = ! randomisiert;
else if (strcmp("-DO", argv[Argument]) == 0) {
Format = Dimacs_Format;
spezRueckgabe = true;
}
else if (strcmp("-XO", argv[Argument]) == 0) {
Format = XML_Format;
spezRueckgabe = false;
}
else if (strcmp("--specification", argv[Argument]) == 0) {
printf("<SAT-solver.specification>\n");
printf(" <solver-type mode = \"deterministic\">\n");
printf(" <complete/>\n");
printf(" </solver-type>\n");
printf(" <solver-name base-name = \"%s\" version = \"%s\" url = \"%s\" />\n", "OKsolver", Version, "http://cs.swan.ac.uk/~csoliver/OKsolver");
printf(" <solver-author first_name = \"Oliver\" last_name = \"Kullmann\" country = \"United Kingdom\" e-mail = \"[email protected]\" www = \"http://cs.swan.ac.uk/~csoliver/\" />\n");
printf(" <programming_language name = \"C\" />\n");
printf(" <compilation_time timestamp = \"%s %s\" />\n", __DATE__, __TIME__);
printf(" <url for = \"executable\" value = \"");
if (argv[0][0] == '/') // absoluter Pfadname
printf("%s\" />\n", argv[0]);
else // relativer Pfadname
printf("%s/%s\" />\n", getenv("PWD"), argv[0]);
printf(" <options string = \"%s\" />\n", OPTIONENKENNUNG5 OPTIONENKENNUNG6 OPTIONENKENNUNG7 OPTIONENKENNUNG1 OPTIONENKENNUNG2 OPTIONENKENNUNG3 OPTIONENKENNUNG4);
{
if (internal)
printf(" <internal/>\n");
}
printf("</SAT-solver.specification>\n");
}
else if (strncmp("--language=", argv[Argument], 11) == 0) {
int Nummer;
if (sscanf(argv[Argument] + 11, "%d", &Nummer) != 1) {
fprintf(stderr, "%s\n", Meldung(18));
return 1;
}
if ((Nummer < 0) || (Nummer >= ANZSPRACHEN)) {
fprintf(stderr, "%s %2d\n", Meldung(19), ANZSPRACHEN - 1);
return 1;
}
Sprache = Nummer;
}
else if (strncmp("--standard=", argv[Argument], 11) == 0) {
int Nummer;
if (sscanf(argv[Argument] + 11, "%d", &Nummer) != 1) {
fprintf(stderr, "%s\n", Meldung(20));
return 1;
}
if ((Nummer <= 0) || (Nummer > ANZSTANDARDS)) {
fprintf(stderr, "%s %2d\n", Meldung(21), ANZSTANDARDS);
return 1;
}
Standard = Nummer;
setzenStandard();
}
else if (strncmp("-D", argv[Argument], 2) == 0) {
// -D fuer Beobachtungstiefe (depth)
// Verzweigungsliterale werden (falls ueberhaupt Dateiausgabe gesetzt ist)
// nur bis zu zwei Stufen unterhalb der Beobachtungsschicht ausgegeben,
// so dass hierfuer als das Beobachtungsniveau mindestens zwei sein
// sollte.
int Nummer;
if (sscanf(argv[Argument] + 2, "%d", &Nummer) != 1) {
fprintf(stderr, "%s\n", Meldung(31));
return 1;
}
if (Nummer < 0) {
fprintf(stderr, "%s\n", Meldung(32));
return 1;
}
Beobachtungsniveau = Nummer;
}
else if (strncmp("-MAXN=", argv[Argument], 6) == 0) {
int maxn;
if (sscanf(argv[Argument] + 6, "%d", &maxn) != 1) {
fprintf(stderr, "%s\n", Meldung(33));
return 1;
}
if (maxn < 0) {
fprintf(stderr, "%s\n", Meldung(34));
return 1;
}
MAXN = maxn;
}
else if (strncmp("-MAXL=", argv[Argument], 6) == 0) {
int maxl;
if (sscanf(argv[Argument] + 6, "%d", &maxl) != 1) {
fprintf(stderr, "%s\n", Meldung(36));
return 1;
}
if (maxl < 0) {
fprintf(stderr, "%s\n", Meldung(37));
return 1;
}
MAXL = maxl;
}
else if (strncmp("-MAXK=", argv[Argument], 6) == 0) {
int maxk;
if (sscanf(argv[Argument] + 6, "%d", &maxk) != 1) {
fprintf(stderr, "%s\n", Meldung(39));
return 1;
}
if (maxk < 0) {
fprintf(stderr, "%s\n", Meldung(40));
return 1;
}
MAXK = maxk;
}
else if (strncmp("--timeout=", argv[Argument], 10) == 0) {
int t;
if (sscanf(argv[Argument] + 10, "%d", &t) != 1) {
fprintf(stderr, "%s\n", Meldung(42));
return 1;
}
if (t < 0) {
fprintf(stderr, "%s\n", Meldung(43));
return 1;
}
Zeitschranke = t;
}
else if (strncmp("-seed=", argv[Argument], 6) == 0) {
long unsigned int S;
if (sscanf(argv[Argument] + 6, "%lud", &S) != 1) {
fprintf(stderr, "%s\n", Meldung(52));
return 1;
}
Schluessel = S;
}
else if (strncmp("-quot=", argv[Argument], 6) == 0) {
double V;
if (sscanf(argv[Argument] + 6, "%lf", &V) != 1)
{
fprintf(stderr, "%s\n", Meldung(53));
return 1;
}
Verhaeltnis = V;
}
else if (strncmp("-", argv[Argument], 1) == 0) {
fprintf(stderr, "%s %s\n", Meldung(22), argv[Argument]);
return 1;
}
else {
aktName = argv[Argument];
s = Unbestimmt;
alarm(Zeitschranke);
#ifndef SYSTIME
akkVerbrauch = clock();
#else
times(Zeiger);
akkVerbrauch = SysZeit.tms_utime;
#endif
if (randomisiert)
srand_S();
if ((fp = fopen(aktName, "r")) == NULL) {
fprintf(stderr, "%s %s\n", Meldung(4), aktName);
return 1;
}
{
struct stat stbuf;
if (stat(aktName, &stbuf) == -1) {
fprintf(stderr, Meldung(7), aktName);
return 1;
}
Groesse = stbuf.st_size;
}
if (Dateiausgabe) {
if ((fpaus = fopen(Ausgabedatei, "a")) == NULL) {
fprintf(stderr, "%s %s\n", Meldung(30), Ausgabedatei);
return 1;
}
if (Belegung || (Monitor && (! nurVorreduktion))) {
Wurzel = BasisName(aktName);
if (Belegung) {
NameBel = (char *) xmalloc((strlen(Wurzel) + 3 + 1) * sizeof(char));
strcpy(NameBel, Wurzel); strcat(NameBel, ".pa");
}
if (Monitor && (! nurVorreduktion)) {
NameMon = (char *) xmalloc((strlen(Wurzel) + 3 + 1) * sizeof(char));
strcpy(NameMon, Wurzel); strcat(NameMon, ".mo");
if ((fpmo = fopen(NameMon, "w")) == NULL) {
fprintf(stderr, "%s %s\n", Meldung(29), NameMon);
return 1;
}
}
}
}
#ifdef OUTPUTTREEDATAXML
{
if (not Wurzel) Wurzel = BasisName(aktName);
NameTreeDataFile = (char*) xmalloc((strlen(Wurzel) + 4 + 1));
strcpy(NameTreeDataFile, Wurzel); strcat(NameTreeDataFile, ".xml");
if ((TreeDataFile = fopen(NameTreeDataFile, "w")) == NULL) {
fprintf(stderr, "%s %s\n", Meldung(54), NameTreeDataFile);
return 1;
}
fprintf(TreeDataFile, "<?xml version=\"1.0\" standalone=\"yes\" ?>\n");
fprintf(TreeDataFile, "<!DOCTYPE t [\n");
fprintf(TreeDataFile, " <!ELEMENT t (t?, t?)>\n");
fprintf(TreeDataFile, " <!ATTLIST t\n");
fprintf(TreeDataFile, " l NMTOKEN #REQUIRED>\n");
fprintf(TreeDataFile, "]>\n\n");
// If already in the preprocessing phase the formula is decided, then no tree-xml-element is output, and thus the file with name NameTreeDataFile does not contain correct xml.
}
#endif
switch (Einlesen(fp, Groesse)) {
case Sat : s = SAT; break;
case Unsat : s = UNSAT; break;
case Fehler :
fprintf(stdout, "%s %s.\n", Meldung(17), aktName);
if (Dateiausgabe)
fprintf(fpaus, "%s %s.\n", Meldung(17), aktName);
goto Aufraeumen;
case Norm :
if (nurVorreduktion)
break;
InitVarLitKlm();
InitSat();
#ifdef LOKALLERNEN
InitlokalesLernen();
#endif
if (Monitor) {
printf("\n%s\n %s, %4d, %10d\n", Meldung(28), aktName, Beobachtungsniveau, Gesamtlast);
printf("%s\n\n", Meldung(55));
if (Dateiausgabe) {
fprintf(fpmo, "# %s %4d %11d\n", aktName, Beobachtungsniveau, Gesamtlast);
fprintf(fpmo, "%s\n", Meldung(56));
}
}
s = SATEntscheidung();
}
Ausgabe :
#ifndef SYSTIME
Verbrauch = clock() - akkVerbrauch;
#else
times(Zeiger);
Verbrauch = SysZeit.tms_utime - akkVerbrauch;
#endif
if (Monitor)
printf("\n");
Statistikzeile(stdout);
if (Dateiausgabe)
Statistikzeile(fpaus);
/* Achtung: Die Analyse der Ausgabe verlangt, dass das allererste */
/* Zeichen die SAT-Zugehoerigkeit (d.h.: 0 oder 1) angibt. */
if (Belegung && (s == SAT)) {
if (! Dateiausgabe)
AusgabeBelegung(stdout);
else {
if ((fppa = fopen(NameBel, "w")) == NULL) {
fprintf(stderr, "%s %s\n", Meldung(27), NameBel);
return 1;
}
AusgabeBelegung(fppa);
}
}
Aufraeumen :
alarm(0);
AufraeumenSat();
#ifdef BAUMRES
AufraeumenBaumRes();
#endif
#ifdef LOKALLERNEN
AufraeumenlokalesLernen();
#endif
AufraeumenEinlesen(); /* zuletzt */
free(NameBel); NameBel = NULL;
free(NameMon); NameMon = NULL;
#ifdef OUTPUTTREEDATAXML
fprintf(TreeDataFile, "\n");
free(NameTreeDataFile); NameTreeDataFile = NULL;
if (TreeDataFile != NULL) {
fclose(TreeDataFile); TreeDataFile = NULL;
}
#endif
if (fp != NULL) {
fclose(fp); fp = NULL;
}
if (fpmo != NULL) {
fclose(fpmo); fpmo = NULL;
}
if (fpaus != NULL) {
fclose(fpaus); fpaus = NULL;
}
if (fppa != NULL) {
fclose(fppa); fppa = NULL;
}
}
}
if (spezRueckgabe)
switch (s) {
case SAT : return 10;
case UNSAT : return 20;
case Unbestimmt : return 0;
}
else
return 0;
}
