Exemplo n.º 1
0
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;
}
Exemplo n.º 2
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;
}
Exemplo n.º 3
0
// *** 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;
}
}
Exemplo n.º 4
0
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;
}
Exemplo n.º 8
0
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;
}
Exemplo n.º 9
0
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;
}
Exemplo n.º 11
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;

}
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;
}
Exemplo n.º 16
0
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;
}