#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <ctype.h>
#include <math.h>

const unsigned long SPINDELMAX=42000;		//größtmögliche Spindeldrehzahl
const unsigned long VORSCHUBMAX=40000;		//größtmöglicher Vorschub
const double PI=3.141592;					//Kreiszahl PI

unsigned long N=1,NN=10000,NNN=10000,Werkzeugnummer=0,WWAnzahl=0,Satz2=0,Satz3=0,Satz4=0,Satz5=0,zww=0,zakt=0;

int iENDE=0, Eilgang=0, Kontrolle=5, ZKontrolle=0, WW1=1, Zwischentest=1,Zykluszwischentest=1;

char antwort;
char pfad[200];																		//dient zur Ein- und Ausgabe  des Programmnamens

//***********************************************************************************************************************************************
char aptdatei[200]= ("C:\\NC\\");	//Pfad, wo die (Eingabe-) Catia-apt-Datei steht
char clogdatei[200]=("C:\\NC\\");	//Pfad, wo die (Eingabe-) Catia-Logdatei steht
char ncdatei[200]=  ("C:\\NC\\");	//Pfad, wo die (Ausgabe-) NC-Datei hingeschrieben werden soll
char logdatei[200]= ("C:\\NC\\");	//Pfad, wo die (Ausgabe-) Logdatei hingeschrieben werden soll
//***********************************************************************************************************************************************

char apterweiterung[]={".aptsource"};		//Istendung der (Eingabe-) apt-Datei
char catialogerweiterung[]={".LOG"};		//Istendung der (Eingabe-) Log-Datei
char ncerweiterung[]={".ncd"};				//Sollendung der (Ausgabe-) NC-Datei
char logerweiterung[]={".nclog"};			//Sollendung der (Ausgabe-) Log-Datei

float X=0,Y=0,Z=0,SSX=0,I=0,J=0,K=0;
float Durchmesser=0,Eckenradius=0,Schneidenlaenge=0,Spindeldrehzahl=1,Drehzahldurchmesser=1,Bohrerwinkel=0;	
float Zmin=0;
float IX=0,IY=0,IZ=0,SX=0,SY=0,SZ=0,MX=0,MY=0,MZ=0,EX=0,EY=0,EZ=0;
float Z_MX=0, Z_MY=0;
float ZwischenX=0,ZwischenY=0,ZwischenZ=0;

char Kennung[100];
char Rest[100];
char fedratstring[100];
char R,S,T;

char Logkennung[]="Information: ** ";
char GOTO[]="GOTO";
char RAPID[]="RAPID";
char FEDRAT[]="FEDRAT/";
char $$[]="$$";
char PPRINT[]="PPRINT";
char TLAXIS[]="TLAXIS/";
char LOADTL[]="LOADTL/";
char CUTTER[]="CUTTER/";
char TPRINT[]="TPRINT/";
char PARTNO[]="PARTNO";
char COOLNTON[]="COOLNT/ON";
char COOLNTOFF[]="COOLNT/OFF";
char SPINDL[]="SPINDL/";
char SPRLUMIN[]=",RPM,CLW";
char SPLLUMIN[]=",RPM,CCLW";
char SPRLSCHN[]=",SFM,CLW";
char SPLLSCHN[]=",SFM,CCLW";
char SPRLSCHN2[]=",SMM,CLW";
char SPLLSCHN2[]=",SMM,CCLW";
char SPINDLOFF[]="SPINDL/OFF";
char REWIND[]="REWIND/0";
char END[]="END";
char TOOLNO[]="TOOLNO/";
char INTOL[]="INTOL";
char OUTTOL[]="OUTTOL/";
char AUTOPS[]="AUTOPS";
char INDIRV[]="INDIRV";
char TLONGOFWD[]="TLON,GOFWD/";
char AUXFUN[]="AUXFUN/";
char AX[]="AX";
char AXSLX[]="AXSLX";
char AXSLY[]="AXSLY";
char AXSLZ[]="AXSLZ";
char AXSNX[]="AXSNX";
char AXSNY[]="AXSNY";
char AXSNZ[]="AXSNZ";
char BLKFRM[]="BLKFRM";
char CUTCOMLEFT[]="CUTCOM/LEFT";
char CUTCOMRIGHT[]="CUTCOM/RIGHT";
char CUTCOMOFF[]="CUTCOM/OFF";
char DELAY[]="DELAY/";
char FINI[]="FINI";
char INSERT[]="INSERT";
char FROM[]="FROM";
char OPSKIPON[]="OPSKIP/ON";
char OPSKIPOFF[]="OPSKIP/OFF";
char STOP[]="STOP";
char PREFUN[]="PREFUN/";
char MODE[]="MODE";
char GODLTA[]="GODLTA/";
char SEQNO[]="SEQNO";

//Name aller Catia-Maschinenzyklen in der apt-Ausgabe
char CYCLEANBOHREN[]="CYCLE/ANBOHREN,$";			
char CYCLEBOHREN[]="CYCLE/BOHREN,$";
char CYCLEBOHRENMITVERWEILZEIT[]="CYCLE/BOHREN_MIT_VERWEILZEIT,$";
char CYCLEBOHRENMITSPANBRUCH[]="CYCLE/BOHREN_MIT_SPANBRUCH,$";
char CYCLETIEFLOCHBOHREN[]="CYCLE/TIEFLOCHBOHREN,$";
char CYCLERECHTSGEWINDE[]="CYCLE/RECHTSGEWINDE,$";
char CYCLELINKSGEWINDE[]="CYCLE/LINKSGEWINDE,$";
char CYCLEREIBEN[]="CYCLE/REIBEN,$";
char CYCLEPLANEINSENKEN[]="CYCLE/PLANEINSENKEN,$";
char CYCLEPROFILEINSENKEN[]="CYCLE/PROFILEINSENKEN,$";
char CYCLEZIRKULARFRAESEN[]="CYCLE/ZIRKULARFRAESEN,$";
char CYCLEGEWINDEFRAESEN[]="CYCLE/GEWINDEFRAESEN,$";
char CYCLEGEWINDESPINDELNMITPLANSCHIEBER[]="CYCLE/GEWINDESPINDELN_MIT_PLANSCHIEBER";
char CYCLEAUSSPINDELN[]="CYCLE/AUSSPINDELN";
char CYCLEAUSSPINDELN_MIT_SPINDELSTOP[]="CYCLE/AUSSPINDELN_MIT_SPINDELSTOP";
char CYCLEBOHRENMITANFASEN[]="CYCLE/BOHREN_MIT_ANFASEN";
char CYCLEBEIDSEITIGESANFASEN[]="CYCLE/BEIDSEITIGES_ANFASEN";
char CYCLETNUTFRAESEN[]="CYCLE/T_NUTFRAESEN";
char CYCLERUECKWAERTSAUSSPINDELN[]="CYCLE/RUECKWAERTS_AUSSPINDELN";

// FUNKTIONEN / ZYKLEN
void sleep(int zeit);			//Pausenfunktion
void neu(void);					//liest Zeichen, bis eine neue Zeile beginnt
void punktaufruf(float Q);		//liest die Positionen des Zyklusaufrufs - für unterstützte Zyklen
void punktaufruf2(void);		//liest Zeichen ein, bis der Zyklus beendet ist (CYCLE/OFF) - für nicht unterstützte Zyklen

void Anbohren(void);			//unterstützte Maschinenzyklen
void Bohren(void);
void BohrenmitVerweilzeit(void);
void BohrenmitSpanbruch(void);
void Tieflochbohren(void);
void Rechtsgewinde(void);
void Linksgewinde(void);
void Reiben(void);
void Planeinsenken(void);
void Profileinsenken(void);

void Gewindespindelnmitplanschieber(void);	//diese	Maschinenzyklen werden nicht unterstützt!!!
void Ausspindeln(void);
void Ausspindelnmitspindelstop(void);
void Bohrenmitanfasen(void);
void Beidseitigesanfasen(void);
void Tnutfraesen(void);
void Rueckwaertsausspindeln(void);


//Streams - Dateien
FILE *apt;
FILE *nc;
FILE *pplog;
FILE *catialog;

int main(void)
{
	fprintf(stderr,"\n****************************** HERZLICH WILLKOMMEN *****************************\n");
	fprintf(stderr,"\nDieses Programm wandelt eine Catia V5 apt-Datei in ein Mikron NC-Programm um!");
	fprintf(stderr,"\nBitte beachten Sie hierbei die Ein- bzw. Ausgabepfade fuer:");
	fprintf(stderr,"\n- CATIA-APT-Datei:\t%s",aptdatei);
	fprintf(stderr,"\n- CATIA-LOG-Datei:\t%s",clogdatei);
	fprintf(stderr,"\n- PP-NC-Datei:\t\t%s",ncdatei);
	fprintf(stderr,"\n- PP-LOG-Datei:\t\t%s",logdatei);
	fprintf(stderr,"\nBitte geben Sie jetzt nur den apt-Dateinamen ein! (ohne *%s)\n\n==>",apterweiterung);
	fflush(stdin);
	fscanf(stdin,"%s",&pfad);
	fflush(stdin);

	strcat(aptdatei,pfad);			//Name der apt-Datei wird an den Eingangspfad angehängt
	strcat(ncdatei,pfad);			//Name der NC-Datei wird an den Ausgangspfad angehängt
	strcat(logdatei,pfad);			//Name der Log-Datei wird an den Ausgangspfad angehängt
	strcat(clogdatei,pfad);			//Name der Catia-Logdatei wird an den Eingangspfad angehängt
	strcat(pfad,ncerweiterung);		
	strcat(aptdatei,apterweiterung);
	strcat(ncdatei,ncerweiterung);
	strcat(logdatei,logerweiterung);
	strcat(clogdatei,catialogerweiterung);

	if ((pplog=fopen(logdatei,"r"))!=NULL)

	{
		while(1)
		{
			printf("\nHINWEIS!!! Die Logdatei %s existiert bereits!\nUEBERSCHREIBEN (Y//N)?\n\n==>",logdatei);
			antwort=getc(stdin);
			fflush(stdin);
			if (antwort=='Y' || antwort=='y')
				break;
			if (antwort=='N' || antwort=='n')
			{
				fprintf(stderr,"\n******************************* AUF WIEDERSEHEN! *******************************\n\n");
				sleep(3);
				exit (-1);
			}
		}
		if(fclose(pplog)==-1)
		{
			fprintf(stderr,"\nFehler beim Schliessen der bereits existierenden Logdatei: %s",logdatei);
			fprintf(stderr,"\n******************************* AUF WIEDERSEHEN! *******************************\n\n");
			sleep(3);
			exit(-1);
		}
	}


	if ((pplog=fopen(logdatei,"w"))==NULL)
	{
		fprintf(stderr,"Fehler beim Anlegen der Log-Datei:\n%s",logdatei);
		fprintf(stderr,"\n******************************* AUF WIEDERSEHEN! *******************************\n\n");
		sleep(3);
		exit(-1);
	}



	if ((nc=fopen(ncdatei,"r"))!=NULL)

	{
		while(1)
		{
			printf("\nHINWEIS!!! Die NC-Datei %s existiert bereits!\nUEBERSCHREIBEN (Y//N)?\n\n==>",ncdatei);
			antwort=getc(stdin);
			fflush(stdin);
			if (antwort=='Y' || antwort=='y')
				break;
			if (antwort=='N' || antwort=='n')
			{
				fprintf(stderr,"\n******************************* AUF WIEDERSEHEN! *******************************\n\n");
				sleep(3);
				exit (-1);
			}
		}
		if(fclose(nc)==-1)
		{
			fprintf(stderr,"\nFehler beim Schliessen der bereits existierenden NC-Datei: %s",ncdatei);
			fprintf(stderr,"\n******************************* AUF WIEDERSEHEN! *******************************\n\n");
			sleep(3);
			exit(-1);
		}
	}


	if ((nc=fopen(ncdatei,"w"))==NULL)
	{
		fprintf(stderr,"Fehler beim Anlegen der NC-Datei:\n%s",ncdatei);
		fprintf(stderr,"\n******************************* AUF WIEDERSEHEN! *******************************\n\n");
		sleep(3);
		exit(-1);
	}



	if ((apt=fopen(aptdatei,"r"))==NULL)
	{
		fprintf(stderr,"Fehler beim Oeffnen der apt-Datei:\n%s",pfad);
		fprintf(stderr,"\n******************************* AUF WIEDERSEHEN! *******************************\n\n");
		sleep(3);
		exit(-1);
	}

	if ((catialog=fopen(clogdatei,"r"))==NULL)
	{
		fprintf(stderr,"Fehler beim Oeffnen der Catia-LOG-Datei:\n%s",clogdatei);
		fprintf(stderr,"\n******************************* AUF WIEDERSEHEN! *******************************\n\n");
		sleep(3);
		exit(-1);
	}

	/********** alle Dateien geöffnet; Beginn des eigentlichen Hauptprogramms... ************/
	fprintf(pplog,"*******************************************************************************");
	fprintf(pplog,"\nHINWEIS- UND FEHLERPROTOKOLL VON PROGRAMM: %s ",pfad);
	fprintf(pplog,"\n*******************************************************************************\n");

	fprintf(nc,"N%ld (PROGRAMMNAME: %s)",N++,pfad);										
	fprintf(nc,"\nN%ld (GESAMTANZAHL WERKZEUGWECHSEL: %5.ld)",N++,WWAnzahl);

	fprintf(nc,"\nN%ld",N++);									//Beginn des Lesens von der Catia-Log-Datei
	fprintf(nc,"\nN%ld (******** PROGRAMMABLAUF LAUT CATIA-LOGDATEI: *********)",N++);
	while(!feof(catialog))
	{
		fgets(Rest,99,catialog);
		if(strncmp(Rest,Logkennung,strlen(Logkennung))==0)		//Testet nach: "Information: ** " in der Catia-Log-Datei
		{
			int l=15;
			fprintf(nc,"\nN%ld\t(",N++);
			while(Rest[l]!='*')
			{
				fprintf(nc,"%c",Rest[l]);
				l++;
			}
			fprintf(nc,")");
		}
	}
	fprintf(nc,"\nN%ld (************* ENDE DER CATIA-LOGDATEI: **************)",N++);
	fprintf(nc,"\nN%ld",N++);									//Ende der Catia-Log-Datei

	while(!feof(apt) && iENDE!=1)
	{
		if(N>NN)
		{
			fprintf(stderr,"\nN%ld berechnet!",NN);
			NN+=NNN;
		}


		Kontrolle=fscanf(apt,"%s",Kennung);
		if(Kontrolle!=1)
		{
			fprintf(pplog,"\nFEHLER: FEHLER BEIM EINLESEN DER KENNUNG!\n");
		}


		if(strncmp(Kennung,GOTO,strlen(GOTO))==0)				 //Testet nach einer GOTO-Anweisung
		{  
			R=fgetc(apt);
			S=fgetc(apt);
			T=fgetc(apt);
			fscanf(apt,"%f%c%f%c%f",&X,&R,&Y,&S,&Z);
			if(Eilgang ==1)
			{
				fprintf(nc,"\nN%ld G0 ",N++);
			}
			else
			{
				fprintf(nc,"\nN%ld G1 ",N++);
			}
			Eilgang = 0;

			if(Zwischentest==0)
			{
				if(floor(X*1000.0+0.5)!=floor(ZwischenX*1000.0+0.5))
				{
					fprintf(nc,"X%.3f ",X);
				}
				if(((X-(floor(X*1000.0+0.5)/1000))>0.000501) || (((floor(X*1000.0+0.5)/1000)-X)>0.000501))
				{
					fprintf(pplog,"\nRundungsfehler mit X-Wert: %f gerundet: %f",X,floor(X*1000.0+0.5)/1000);
					fprintf(pplog,"\nFehlerdifferenz: %f\n",X-(floor(X*1000.0+0.5)/1000));
				}

				if(floor(Y*1000.0+0.5)!=floor(ZwischenY*1000.0+0.5))
				{
					fprintf(nc,"Y%.3f ",Y);
				}
				if(((Y-(floor(Y*1000.0+0.5)/1000))>0.000501) || (((floor(Y*1000.0+0.5)/1000)-Y)>0.000501))
				{
					fprintf(pplog,"\nRundungsfehler mit Y-Wert: %f gerundet: %f",Y,floor(Y*1000.0+0.5)/1000);
					fprintf(pplog,"\nFehlerdifferenz: %f\n",Y-(floor(Y*1000.0+0.5)/1000));
				}

				if(floor(Z*1000.0+0.5)!=floor(ZwischenZ*1000.0+0.5))
				{
					fprintf(nc,"Z%.3f",Z);
				}
				if(((Z-(floor(Z*1000.0+0.5)/1000))>0.000501) || (((floor(Z*1000.0+0.5)/1000)-Z)>0.000501))
				{
					fprintf(pplog,"\nRundungsfehler mit Z-Wert: %f gerundet: %f",Z,floor(Z*1000.0+0.5)/1000);
					fprintf(pplog,"\nFehlerdifferenz: %f\n",Z-(floor(Z*1000.0+0.5)/1000));
				}
			}

			else
			{
				fprintf(nc,"X%.3f Y%.3f Z%.3f",X,Y,Z);
				Zwischentest=0;
			}
			ZwischenX=X;
			ZwischenY=Y;
			ZwischenZ=Z;

			if((Z<Zmin)||(ZKontrolle==0))
			{
				Zmin=Z;
				ZKontrolle=1;
			}
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der GOTO-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,INDIRV,strlen(INDIRV))==0)			//Testet nach der INDIRV-Anweisung
		{
			fscanf(apt,"%f%c%f%c%f",&IX,&R,&IY,&S,&IZ);
			if(IZ!=0)
			{
				fprintf(pplog,"FEHLER: Z-Wert der INDIRV-Anweisung ist ungleich 0 -> 3D-Kreis?");
			}
			fgets(Rest,99,apt);
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der INDIRV-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,TLONGOFWD,strlen(TLONGOFWD))==0)			//Testet nach der TLON,GOFWD-Anweisung
		{
			if(ZKontrolle==0)
			{
				fprintf(pplog,"FEHLER: KREISSATZ OHNE DEFINIERTEN STARTPUNKT! (POSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN?)");
			}
			SX=X;
			SY=Y;
			SZ=Z;
			fgets(Rest,99,apt);
			R=fgetc(apt);                             
			while(R!='/')                            
			{
				R=fgetc(apt);
			}
			fscanf(apt,"%f%c %f%c %f%c",&MX,&R,&MY,&S,&MZ,&T);
			fgets(Rest,99,apt);
			fscanf(apt,"%f%c %f%c %f",&EX,&R,&EY,&S,&EZ);
			fgets(Rest,99,apt);
			Z_MX=MX-SX;
			Z_MY=MY-SY;

			//fprintf(nc,"\n\tINDIRV:         IX %f IY %f IZ %f",IX,IY,IZ);
			//fprintf(nc,"\n\tStartpunkte:    SX %f SY %f SZ %f",SX,SY,SZ);
			//fprintf(nc,"\n\tMittelpunkte:   MX %f MY %f MZ %f",MX,MY,MZ);
			//fprintf(nc,"\n\tEndpunkte:      EX %f EY %f EZ %f",EX,EY,EZ);
			//fprintf(nc,"\n\tZwischenpunkte: Z_MX %f Z_MY %f",Z_MX,Z_MY);		

			if((EZ<Zmin)||(ZKontrolle==0))
			{
				Zmin=EZ;
				ZKontrolle=1;
			}

			if((IX>=0) & (IY>0) & (Z_MX>0))
			{
				fprintf(nc,"\nN%ld G2 ",N++);
			}
			else if((IX>=0) & (IY>0) & (Z_MX<0))
			{
				fprintf(nc,"\nN%ld G3 ",N++);
			}


			else if((IX<0) & (IY>=0) & (Z_MY>0))
			{
				fprintf(nc,"\nN%ld G2 ",N++);
			}
			else if((IX<0) & (IY>=0) & (Z_MY<0))
			{
				fprintf(nc,"\nN%ld G3 ",N++);
			}


			else if((IX<=0) & (IY<0) & (Z_MX<0))
			{
				fprintf(nc,"\nN%ld G2 ",N++);
			}
			else if((IX<=0) & (IY<0) & (Z_MX>0))
			{
				fprintf(nc,"\nN%ld G3 ",N++);
			}


			else if((IX>0) & (IY<=0) & (Z_MY<0))
			{
				fprintf(nc,"\nN%ld G2 ",N++);
			}
			else if((IX>0) & (IY<=0) & (Z_MY>0))
			{
				fprintf(nc,"\nN%ld G3 ",N++);
			}

			else
			{
				fprintf(pplog,"\nFEHLER: DEFAULTANWEISUNG IN DER KREISBERECHNUNG ERREICHT!");
			}

			if(EZ==SZ)
			{
				fprintf(nc,"X%.3f Y%.3f I%.3f J%.3f",EX,EY,MX,MY);
			}
			if(EZ!=SZ)
			{
				fprintf(nc,"X%.3f Y%.3f Z%.3f I%.3f J%.3f K%.3f",EX,EY,EZ,MX,MY,MZ);
				fprintf(pplog,"\nFEHLER: Z-WERT BEI KREISANFANG IST NICHT GLEICH Z-WERT BEI KREISENDE -> 3D-KREIS???");
				fprintf(pplog,"\nWERTE:   EINGANG: %f   AUSGANG: %f\n",EZ,MZ);
			}

			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der TLON,GOFWD-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,RAPID,strlen(RAPID))==0)				 //Testet nach der RAPID-Anweisung
		{                                       
			Eilgang = 1;
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der RAPID-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,FEDRAT,strlen(FEDRAT))==0)			 //Testet nach einer FEDRAT-Anweisung
		{
			Eilgang = 0;
			if(strlen(Kennung)==strlen(FEDRAT)) //1.Möglichkeit z.B. FEDRAT/ 20000.0000,MMPM (Leerzeichen nach FEDRAT/)
			{
				fscanf(apt,"%f",&X);
				R=fgetc(apt);
				fscanf(	apt,"%s",Rest);
			}

			else								//2.Möglichkeit z.B.FEDRAT/20000.0000,MMPM (kein Leerzeichen!!!)
			{
				for(unsigned int r=0;r<strlen(fedratstring);r++)	//fedratstring wird mit x-Zeichen initialisiert
				{
					fedratstring[r]='x';
				}
				for(unsigned int o=0,q=0;o<strlen(Kennung);o++)		//in fedratstring werden nur Zahlen und der Punkt geschrieben
				{
					if(isdigit(Kennung[o]) || Kennung[o]=='.')
					{
						fedratstring[q]=Kennung[o];
						q++;
					}
				}

				X=(float) atof(fedratstring);						//aus fedratstring wird der Vorschubwert entnommen
				r=0;
				while(r<strlen(Kennung) && Kennung[r]!='\n')
				{
					if(Kennung[r]!=',')								//Die Kennung wird bis zum Komma durchlaufen
					{
						r++;
						continue;
					}

					r++;											//Die Kennung steht jetzt beim Komma

					for(q=0;q<5;q++,r++)							//Die Kennung steht jetzt beim MMPM bzw. MMPR bzw. sonstiges
					{											
						Rest[q]=Kennung[r];
					}
					Rest[q]='\n';
					break;
					fprintf(pplog,"\nC++ FEHLER: Ende der FEDRAT/WHILE-Überprüfung erreicht!\nPROGRAMMCODE ÜBERPRÜFEN!\n");
				}

			}														//Ende von Möglichkeit2

			if(strncmp(Rest,"MMPM",strlen("MMPM"))==0)
			{
				if(X>VORSCHUBMAX)
				{
					X=VORSCHUBMAX;
				}
				fprintf(nc,"\nN%ld F%.0f",N++,X);
				continue;
				fprintf(pplog,"\nC++ FEHLER: Ende der FEDRAT-MMPM-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
			}

			else if(strncmp(Rest,"MMPR",strlen("MMPR"))==0)
			{
				X*=Spindeldrehzahl;
				if(X>VORSCHUBMAX)
				{
					X=VORSCHUBMAX;
				}
				fprintf(nc,"\nN%ld F%.0f",N++,X);
				continue;
				fprintf(pplog,"\nC++ FEHLER: Ende der FEDRAT-MMPR-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
			}
			else
			{
				fprintf(pplog,"\nFEHLER: Einheit des Vorschubs wurde nicht erkannt! (Inch???)");
				continue;
				fprintf(pplog,"\nC++ FEHLER: Ende der FEDRAT-FEHLER-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
			}
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der FEDRAT-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n"); 
		}

		if(strncmp(Kennung,$$,strlen($$))==0)					//Testet nach den $$-Zeichen
		{                                      
			fgets(Rest,99,apt);                  
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der $$-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,PPRINT,strlen(PPRINT))==0)			//Testet nach einer PPRINT-Anweisung
		{
			fprintf(nc,"\nN%ld (",N++);
			R=fgetc(apt);
			while(1)
			{
				R=fgetc(apt);
				if(R=='\n')
				{
					break;
				}
				fprintf(nc,"%c",R);
			}
			fprintf(nc,")");
			continue;
		}

		if(strncmp(Kennung,CUTTER,strlen(CUTTER))==0)			 //Testet nach einer CUTTER-Anweisung
		{
			fscanf(apt,"%f%c%f%c%f%c%f%c%f%c%c%f%c%f",&Durchmesser,&R,&Eckenradius,&R,&SSX,&R,&SSX,&R,&Bohrerwinkel,&R,&R,&SSX,&R,&Schneidenlaenge);
			fprintf(nc,"\nN%ld",N++);
			fprintf(nc,"\nN%ld (------ WERKZEUGBESCHREIBUNG ------)",N++);
			fprintf(nc,"\nN%ld (Durchmesser:\t\t%10.3f)",N++,Durchmesser);
			fprintf(nc,"\nN%ld (Schneidenlaenge:\t%10.3f)",N++,Schneidenlaenge);
			fprintf(nc,"\nN%ld (Eckenradius:\t\t%10.3f)",N++,Eckenradius);
			fprintf(nc,"\nN%ld (Spitzenwinkel:\t%10.3f)",N++,180-2*Bohrerwinkel);
			fprintf(nc,"\nN%ld (----------------------------------)",N++);
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der CUTTER-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,TPRINT,strlen(TPRINT))==0)			//Testet nach einer TPRINT-Anweisung
		{
			fprintf(nc,"\nN%ld (WERKZEUGNAME: ",N++);
			unsigned int k=7;

			while(k<strlen(Kennung))
			{
				fprintf(nc,"%c",Kennung[k]);
				k++;
			}
			R=fgetc(apt);                             
			while(R!='\n')                            
			{
				fprintf(nc,"%c",R);
				R=fgetc(apt);
			}
			fprintf(nc,")");
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der TPRINT-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,LOADTL,strlen(LOADTL))==0)			 //Testet nach einer LOADTL-Anweisung
		{
			fprintf(nc,"\nN%ld (Z-MINIMUM:    ",N++);

			if(WW1!=1)
			{
				zakt=ftell(nc);
				if(zakt==-1)
				{
					fprintf(pplog,"\nFEHLER BEI DER FTELL-ANWEISUNG (PARAMETER: ZAKT) IN DER KENNUNG LOADTL!\n");
				}
				if(fseek(nc,zww,SEEK_SET)!=0)
				{
					fprintf(pplog,"\nFEHLER BEIM EINSATZ VON FSEEK (PARAMETER: ZWW) IN DER KENNUNG LOADTL!\n");
				}

				fprintf(nc,"\t%10.3f)",Zmin);
				if(fseek(nc,zakt,SEEK_SET)!=0)
				{
					fprintf(pplog,"\nFEHLER BEIM EINSATZ VON FSEEK (PARAMETER: ZAKT) IN DER KENNUNG LOADTL!\n");
				}
				ZKontrolle=0;
			}

			zww=ftell(nc);
			if(zww==-1)
			{
				fprintf(pplog,"\nFEHLER BEI DER FTELL-ANWEISUNG (PARAMETER: ZWW) IN DER KENNUNG LOADTL!\n");
			}
			fprintf(nc,"                              ");
			fprintf(nc,"\nN%ld (----------------------------------)",N++);

			WW1=0;
			fprintf(nc,"\nN%ld T",N++);
			unsigned int k=7;

			while(k<strlen(Kennung))
			{
				fprintf(nc,"%c",Kennung[k]);
				k++;
			}
			fprintf(nc," M6");
			fprintf(nc,"\nN%ld M0",N++);
			WWAnzahl+=1;
			fprintf(nc,"\nN%ld G90 G0 G40 X%.3f Y%.3f Z%.3f M50",N++,X,Y,Z);
			Zwischentest=1;
			fprintf(nc,"\nN%ld",N++);
			if((Z<Zmin)||(ZKontrolle==0))
			{
				Zmin=Z;
				ZKontrolle=1;
			}
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der LOADTL-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,TLAXIS,strlen(TLAXIS))==0)			 //Testet nach einer TLAXIS-Anweisung
		{  
			fscanf(apt,"%f%c%f%c%f",&X,&R,&Y,&S,&Z);
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der TLAXIS-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,TOOLNO,strlen(TOOLNO))==0)			//Testet nach einer TOOLNO-Anweisung
		{
			fscanf(apt,"%f",&Drehzahldurchmesser);
			//fprintf(nc,"\nN%ld (DURCHMESSER BEI BERECHNUNG:\nN%ld\t\t%.3f)",N++,N++,Drehzahldurchmesser);
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der TOOLNO-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,PARTNO,strlen(PARTNO))==0)			//Testet nach einer PARTNO-Anweisung
		{
			fgets(Rest,99,apt);
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der PARTNO-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}


		if(strncmp(Kennung,COOLNTON,strlen(COOLNTON))==0)		//Testet nach den COOLNT/ON-Zeichen
		{                                                    
			fprintf(nc,"\nN%ld M50",N++);
			fgets(Rest,99,apt);                  
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der COOLNT-ON-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}
		if(strncmp(Kennung,COOLNTOFF,strlen(COOLNTOFF))==0)		 //Testet nach den COOLNT/OFF-Zeichen
		{                                                     
			fprintf(nc,"\nN%ld M51",N++);
			fgets(Rest,99,apt);                  
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der COOLNT-OFF-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,OPSKIPON,strlen(OPSKIPON))==0)			//Testet nach der OPSKIPON-Anweisung
		{                                                     
			fgets(Rest,99,apt);
			fprintf(pplog,"\nFEHLER: OPSKIPON-ANWEISUNG (SATZEIN- UND AUSBLENDEN) - KEINE AUSWIRKUNG IM PROGRAMM - POSTPROZESSOR ANPASSEN!\n");
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der OPSKIPON-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}
		if(strncmp(Kennung,OPSKIPOFF,strlen(OPSKIPOFF))==0)			//Testet nach der OPSKIPOFF-Anweisung
		{                                                     
			fgets(Rest,99,apt);
			fprintf(pplog,"\nFEHLER: OPSKIPOFF-ANWEISUNG (SATZEIN- UND AUSBLENDEN) - KEINE AUSWIRKUNG IM PROGRAMM - POSTPROZESSOR ANPASSEN!\n");
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der OPSKIPOFF-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,CUTCOMLEFT,strlen(CUTCOMLEFT))==0)		//Testet nach den CUTCOM/LEFT-Zeichen
		{                                                     
			fgets(Rest,99,apt);
			fprintf(pplog,"\nFEHLER: BAHNKORREKTUR LINKS AKTIVIERT! - KEINE AUSWIRKUNG IM PROGRAMM - POSTPROZESSOR ANPASSEN!\n");
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der CUTCOM-OFF-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}
		if(strncmp(Kennung,CUTCOMRIGHT,strlen(CUTCOMRIGHT))==0)		//Testet nach den CUTCOM/RIGHT-Zeichen
		{                                                     
			fgets(Rest,99,apt);
			fprintf(pplog,"\nFEHLER: BAHNKORREKTUR RECHTS AKTIVIERT! - KEINE AUSWIRKUNG IM PROGRAMM - POSTPROZESSOR ANPASSEN!\n");
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der CUTCOM-OFF-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}
		if(strncmp(Kennung,CUTCOMOFF,strlen(CUTCOMOFF))==0)			//Testet nach den CUTCOM/OFF-Zeichen
		{                                                     
			fgets(Rest,99,apt);                  
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der CUTCOM-OFF-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,AUTOPS,strlen(AUTOPS))==0)				//Testet nach der AUTOPS-Anweisung
		{                                      
			fgets(Rest,99,apt);
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der AUTOPS-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,SPINDLOFF,strlen(SPINDLOFF))==0)			//Testet nach der SPINDL/OFF-Anweisung
		{
			fprintf(nc,"\nN%ld M5",N++);
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der SPINDL-OFF-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,SPINDL,strlen(SPINDL))==0)				//Testet nach einer SPINDL-Anweisung
		{
			fscanf(apt,"%f",&Spindeldrehzahl);
			fscanf(apt,"%s",Rest);


			if(strncmp(Rest,SPRLUMIN,strlen(SPRLUMIN))==0)
			{
				fprintf(nc,"\nN%ld S%.0f M3",N++,Spindeldrehzahl);
				continue;
				fprintf(pplog,"\nC++ FEHLER: Ende der SPINDL-RL-UMIN-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
			}


			if(strncmp(Rest,SPLLUMIN,strlen(SPLLUMIN))==0)
			{
				fprintf(nc,"\nN%ld S%.0f M4",N++,Spindeldrehzahl);
				continue;
				fprintf(pplog,"\nC++ FEHLER: Ende der SPINDL-LL-UMIN-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
			}


			if((strncmp(Rest,SPRLSCHN,strlen(SPRLSCHN))==0) || (strncmp(Rest,SPRLSCHN2,strlen(SPRLSCHN2))==0))
			{
				if (Drehzahldurchmesser!=0)
				{
					Spindeldrehzahl=(1000*Spindeldrehzahl)/(Drehzahldurchmesser*(float) PI);
					if(Spindeldrehzahl>SPINDELMAX)
					{
						Spindeldrehzahl=SPINDELMAX;
					}
					fprintf(nc,"\nN%ld S%.0f M3",N++,Spindeldrehzahl);
				}
				else
				{
					fprintf(nc,"\nN%ld S%.0f M3",N++,SPINDELMAX);
				}
				continue;
				fprintf(pplog,"\nC++ FEHLER: Ende der SPINDL-RL-SCHN-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
			}


			if((strncmp(Rest,SPLLSCHN,strlen(SPLLSCHN))==0) || (strncmp(Rest,SPLLSCHN2,strlen(SPLLSCHN2))==0))
			{
				if (Drehzahldurchmesser!=0)
				{
					Spindeldrehzahl=(1000*Spindeldrehzahl)/(Drehzahldurchmesser*(float) PI);
					if(Spindeldrehzahl>SPINDELMAX)
					{
						Spindeldrehzahl=SPINDELMAX;
					}
					fprintf(nc,"\nN%ld S%.0f M4",N++,Spindeldrehzahl);
				}
				else
				{
					fprintf(nc,"\nN%ld S%.0f M4",N++,SPINDELMAX);
				}
				continue;
				fprintf(pplog,"\nC++ FEHLER: Ende der SPINDL-LL-SCHN-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
			}


			else
			{
				fprintf(pplog,"\nFEHLER: UMWANDLUNGSFEHLER BEI SPINDELDREHZAHL!\n");
				fprintf(pplog,"\n%s %f %s",Kennung,Spindeldrehzahl,Rest);
				continue;
			}
			fprintf(pplog,"\nC++ FEHLER: Ende der SPINDL-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,INTOL,strlen(INTOL))==0)				//Testet nach der INTOL-Anweisung
		{
			R=fgetc(apt);
			R=fgetc(apt);
			fprintf(nc,"\nN%ld (KREISINTERPOLATIONSGENAUIGKEIT INNEN:\t",N++);
			while(1)
			{
				R=fgetc(apt);
				if(R=='\n')
				{
					break;
				}
				else
				{
					fprintf(nc,"%c",R);
				}
			}
			fprintf(nc,")");
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der INTOL-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,OUTTOL,strlen(OUTTOL))==0)				//Testet nach der OUTTOL-Anweisung
		{
			fprintf(nc,"\nN%ld (KREISINTERPOLATIONSGENAUIGKEIT AUSSEN:\t",N++);
			while(1)
			{
				R=fgetc(apt);
				if(R=='\n')
				{
					break;
				}
				else
				{
					fprintf(nc,"%c",R);
				}
			}
			fprintf(nc,")");
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der OUTTOL-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}


		if(strncmp(Kennung,REWIND,strlen(REWIND))==0)			//Testet nach der REWIND-Anweisung
		{
			if(WW1!=1)
			{
				zakt=ftell(nc);
				if(zakt==-1)
				{
					fprintf(pplog,"\nFEHLER BEI DER FTELL-ANWEISUNG (PARAMETER: ZAKT) IN DER KENNUNG REWIND!\n");
				}
				if(fseek(nc,zww,SEEK_SET)!=0)
				{
					fprintf(pplog,"\nFEHLER BEIM EINSATZ VON FSEEK (PARAMETER: ZWW) IN DER KENNUNG REWIND!\n");
				}

				fprintf(nc,"\t%10.3f)",Zmin);
				if(fseek(nc,zakt,SEEK_SET)!=0)
				{
					fprintf(pplog,"\nFEHLER BEIM EINSATZ VON FSEEK (PARAMETER: ZAKT) IN DER KENNUNG REWIND!\n");
				}
				ZKontrolle=0;
			}
			WW1=0;
			fprintf(nc,"\nN%ld M30",N++);
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der REWIND-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,PREFUN,strlen(PREFUN))==0)			//Testet nach einer PREFUN (G)-Anweisung
		{
			fprintf(nc,"\nN%ld G",N++);
			unsigned int i=7;
			while(i<strlen(Kennung))
			{
				fprintf(nc,"%c",Kennung[i]);
				i++;
			}
			fprintf(pplog,"\nHINWEIS: ZUSAETZLICHER G-BEFEHL WURDE ERZEUGT IN NC-ZEILE: %ld\n",N-1);
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der PREFUN-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}


		if(strncmp(Kennung,AUXFUN,strlen(AUXFUN))==0)			//Testet nach einer AUXFUN (M)-Anweisung
		{
			fprintf(nc,"\nN%ld M",N++);
			unsigned int g=7;
			while(g<strlen(Kennung))
			{
				fprintf(nc,"%c",Kennung[g]);
				g++;
			}
			fprintf(pplog,"\nHINWEIS: ZUSAETZLICHER M-BEFEHL WURDE ERZEUGT IN NC-ZEILE: %ld\n",N-1);
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der AUXFUN-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,MODE,strlen(MODE))==0)			 //Testet nach einer MODE-Anweisung
		{  
			fscanf(apt,"%s",Rest);
			char ZXPLAN[]="ZXPLAN";
			char YZPLAN[]="YZPLAN";
			char XYPLAN[]="XYPLAN";
			if(strncmp(Rest,ZXPLAN,strlen(ZXPLAN))==0)
			{
				fprintf(pplog,"\nFEHLER: MODE ZXPLAN-ANWEISUNG ENTDECKT -> PROGRAMM IST UNBRAUCHBAR!!!\n");
			}
			else if(strncmp(Rest,YZPLAN,strlen(YZPLAN))==0)
			{
				fprintf(pplog,"\nFEHLER: MODE YZPLAN-ANWEISUNG ENTDECKT -> PROGRAMM IST UNBRAUCHBAR!!!\n");
			}
			else if(strncmp(Rest,XYPLAN,strlen(XYPLAN))==0)
			{
				fprintf(pplog,"\nHINWEIS: MODE XYPLAN-ANWEISUNG ENTDECKT!!!\n");
			}
			else
			{
				fprintf(pplog,"\nFEHLER: MODE-ANWEISUNG ENTDECKT, ABER NICHT AUSGEWERTET!!!\n");
			}
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der MODE-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,BLKFRM,strlen(BLKFRM))==0)			//Testet nach einer BLKFRM-Anweisung
		{                                      
			fgets(Rest,99,apt); 
			fprintf(pplog,"\nFEHLER ES BEFINDET SICH EINE BLKFRM-ANWEISUNG IM APT-CODE!");
			fprintf(pplog,"\nWERTE: %s\n",Rest);
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der BLKFRM-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,GODLTA,strlen(GODLTA))==0)			//Testet nach einer GODLTA-Anweisung
		{                                      
			fgets(Rest,99,apt); 
			fprintf(pplog,"\nFEHLER ES BEFINDET SICH EINE GODLTA-ANWEISUNG (G91) IM APT-CODE!");
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der GODLTA-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,SEQNO,strlen(SEQNO))==0)				//Testet nach einer SEQNO-Anweisung
		{                                      
			fgets(Rest,99,apt); 
			fprintf(pplog,"\nFEHLER ES BEFINDET SICH EINE SEQNO-ANWEISUNG (DURCHNUMERIEREN) IM APT-CODE!");
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der SEQNO-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,DELAY,strlen(DELAY))==0)				//Testet nach einer DELAY-Anweisung
		{
			fprintf(nc,"\nN%ld G4 F",N++);
			fscanf(apt,"%f",&X);
			fprintf(nc,"%.1f",X);
			fprintf(pplog,"\nHINWEIS: VERWEILZEIT WURDE ERZEUGT IN NC-ZEILE: %ld\n",N-1);
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der DELAY-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,STOP,strlen(STOP))==0)				//Testet nach einer STOP-Anweisung
		{
			fprintf(nc,"\nN%ld M0",N++);
			fprintf(pplog,"\nHINWEIS: PROGRAMMIERTER STOP (M0) WURDE ERZEUGT IN NC-ZEILE: %ld\n",N-1);
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der STOP-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,FROM,strlen(FROM))==0)				 //Testet nach einer FROM-Anweisung
		{  
			R=fgetc(apt);
			S=fgetc(apt);
			T=fgetc(apt);
			fscanf(apt,"%f%c%f%c%f",&X,&R,&Y,&S,&Z);
			if(Eilgang ==1)
			{
				fprintf(nc,"\nN%ld G0 ",N++);
			}
			else
			{
				fprintf(nc,"\nN%ld G1 ",N++);
			}
			Eilgang = 0;

			if(Zwischentest==0)
			{
				if(floor(X*1000.0+0.5)!=floor(ZwischenX*1000.0+0.5))
				{
					fprintf(nc,"X%.3f ",X);
				}
				if(((X-(floor(X*1000.0+0.5)/1000))>0.000501) || (((floor(X*1000.0+0.5)/1000)-X)>0.000501))
				{
					fprintf(pplog,"\nRundungsfehler mit X-Wert: %f gerundet: %f",X,floor(X*1000.0+0.5)/1000);
					fprintf(pplog,"\nFehlerdifferenz: %f\n",X-(floor(X*1000.0+0.5)/1000));
				}

				if(floor(Y*1000.0+0.5)!=floor(ZwischenY*1000.0+0.5))
				{
					fprintf(nc,"Y%.3f ",Y);
				}
				if(((Y-(floor(Y*1000.0+0.5)/1000))>0.000501) || (((floor(Y*1000.0+0.5)/1000)-Y)>0.000501))
				{
					fprintf(pplog,"\nRundungsfehler mit Y-Wert: %f gerundet: %f",Y,floor(Y*1000.0+0.5)/1000);
					fprintf(pplog,"\nFehlerdifferenz: %f\n",Y-(floor(Y*1000.0+0.5)/1000));
				}

				if(floor(Z*1000.0+0.5)!=floor(ZwischenZ*1000.0+0.5))
				{
					fprintf(nc,"Z%.3f",Z);
				}
				if(((Z-(floor(Z*1000.0+0.5)/1000))>0.000501) || (((floor(Z*1000.0+0.5)/1000)-Z)>0.000501))
				{
					fprintf(pplog,"\nRundungsfehler mit Z-Wert: %f gerundet: %f",Z,floor(Z*1000.0+0.5)/1000);
					fprintf(pplog,"\nFehlerdifferenz: %f\n",Z-(floor(Z*1000.0+0.5)/1000));
				}
			}

			else
			{
				fprintf(nc,"X%.3f Y%.3f Z%.3f",X,Y,Z);
				Zwischentest=0;
			}
			ZwischenX=X;
			ZwischenY=Y;
			ZwischenZ=Z;

			if((Z<Zmin)||(ZKontrolle==0))
			{
				Zmin=Z;
				ZKontrolle=1;
			}
			fprintf(pplog,"\nHINWEIS: UMWANDLUNG EINES FROM-BEFEHLS IN NC-ZEILE: %ld\n",N-1);
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der FROM-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,INSERT,strlen(INSERT))==0)					//Testet nach einer INSERT-Anweisung
		{
			fprintf(nc,"\nN%ld",N++);
			R=fgetc(apt);
			while(R!='\n')
			{
				fprintf(nc,"%c",R);
				R=fgetc(apt);
			}
			fprintf(pplog,"\nHINWEIS: INSERT-ANWEISUNG WURDE UMGESETZT IN NC-ZEILE: %ld",N-1);
			fprintf(pplog,"\nACHTUNG: EINGEFUEGTE Z-WERTE WERDEN BEIM Z-MINIMUMWERT NICHT BERUECKSICHTIGT!!!\n");
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der INSERT-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,AXSLX,strlen(AXSLX))==0)					//Testet nach einer AXSLX-Anweisung
		{                                      
			fgets(Rest,99,apt);
			fprintf(pplog,"\nFEHLER ES BEFINDET SICH EINE AXSLX-ANWEISUNG IM APT-CODE!");
			fprintf(pplog,"\nWERTE: %s",Rest);
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der AXSLX-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,AXSLY,strlen(AXSLY))==0)					//Testet nach einer AXSLY-Anweisung
		{                                      
			fgets(Rest,99,apt); 
			fprintf(pplog,"\nFEHLER ES BEFINDET SICH EINE AXSLY-ANWEISUNG IM APT-CODE!");
			fprintf(pplog,"\nWERTE: %s",Rest);
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der AXSLY-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,AXSLZ,strlen(AXSLZ))==0)					//Testet nach einer AXSLZ-Anweisung
		{                                      
			fgets(Rest,99,apt); 
			fprintf(pplog,"\nFEHLER ES BEFINDET SICH EINE AXSLZ-ANWEISUNG IM APT-CODE!");
			fprintf(pplog,"\nWERTE: %s",Rest);
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der AXSLZ-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,AXSNX,strlen(AXSNX))==0)					//Testet nach einer AXSNX-Anweisung
		{                                      
			fgets(Rest,99,apt); 
			fprintf(pplog,"\nFEHLER ES BEFINDET SICH EINE AXSNX-ANWEISUNG IM APT-CODE!");
			fprintf(pplog,"\nWERTE: %s",Rest);
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der AXSNX-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,AXSNY,strlen(AXSNY))==0)					//Testet nach einer AXSNY-Anweisung
		{                                      
			fgets(Rest,99,apt); 
			fprintf(pplog,"\nFEHLER ES BEFINDET SICH EINE AXSNY-ANWEISUNG IM APT-CODE!");
			fprintf(pplog,"\nWERTE: %s",Rest);
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der AXSNY-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,AXSNZ,strlen(AXSNZ))==0)					//Testet nach einer AXSNZ-Anweisung
		{                                      
			fgets(Rest,99,apt); 
			fprintf(pplog,"\nFEHLER ES BEFINDET SICH EINE AXSNZ-ANWEISUNG IM APT-CODE!");
			fprintf(pplog,"\nWERTE: %s",Rest);
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der AXSNZ-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,AX,strlen(AX))==0)						//Testet nach einer AX-Anweisung
		{                                      
			fgets(Rest,99,apt); 
			fprintf(pplog,"\nFEHLER ES BEFINDET SICH EINE AX-ANWEISUNG IM APT-CODE!");
			fprintf(pplog,"\nWERTE: %s",Rest);
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der AX-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}
//*************************************************************************************************************************
//******************************************************* Z Y K L E N *****************************************************

		if(strncmp(Kennung,CYCLEANBOHREN,strlen(CYCLEANBOHREN))==0)
		{
			Anbohren();
			//fprintf(pplog,"\nZurueck aus der Funktion Anbohren!");
			continue;
		}

		if(strncmp(Kennung,CYCLEBOHREN,strlen(CYCLEBOHREN))==0)
		{
			Bohren();
			//fprintf(pplog,"\nZurueck aus der Funktion Bohren!");
			continue;
		}

		if(strncmp(Kennung,CYCLEBOHRENMITVERWEILZEIT,strlen(CYCLEBOHRENMITVERWEILZEIT))==0)
		{
			BohrenmitVerweilzeit();
			//fprintf(pplog,"\nZurueck aus der Funktion Anbohren von Bohren mit Verweilzeit!");
			continue;
		}

		if(strncmp(Kennung,CYCLEBOHRENMITSPANBRUCH,strlen(CYCLEBOHRENMITSPANBRUCH))==0)
		{
			BohrenmitSpanbruch();
			//fprintf(pplog,"\nZurueck aus der Funktion Bohren mit Spanbruch!");
			continue;
		}

		if(strncmp(Kennung,CYCLETIEFLOCHBOHREN,strlen(CYCLETIEFLOCHBOHREN))==0)
		{
			Tieflochbohren();
			//fprintf(pplog,"\nZurueck aus der Funktion Tieflochbohren!");
			continue;
		}
		if(strncmp(Kennung,CYCLERECHTSGEWINDE,strlen(CYCLERECHTSGEWINDE))==0)
		{
			Rechtsgewinde();
			//fprintf(pplog,"\nZurueck aus der Funktion Rechtsgewinde!");
			continue;
		}
		if(strncmp(Kennung,CYCLELINKSGEWINDE,strlen(CYCLELINKSGEWINDE))==0)
		{
			Linksgewinde();
			//fprintf(pplog,"\nZurueck aus der Funktion Linksgewinde!");
			continue;
		}
		if(strncmp(Kennung,CYCLEREIBEN,strlen(CYCLEREIBEN))==0)
		{
			Reiben();
			//fprintf(pplog,"\nZurueck aus der Funktion Reiben!");
			continue;
		}
		if(strncmp(Kennung,CYCLEPLANEINSENKEN,strlen(CYCLEPLANEINSENKEN))==0)
		{
			Planeinsenken();
			//fprintf(pplog,"\nZurueck aus der Funktion Planeinsenken!");
			continue;
		}
		if(strncmp(Kennung,CYCLEPROFILEINSENKEN,strlen(CYCLEPROFILEINSENKEN))==0)
		{
			Profileinsenken();
			//fprintf(pplog,"\nZurueck aus der Funktion Profileinsenken!");
			continue;
		}



		//Anfang der nicht unterstützten Zyklen!!!
		if(strncmp(Kennung,CYCLEGEWINDESPINDELNMITPLANSCHIEBER,strlen(CYCLEGEWINDESPINDELNMITPLANSCHIEBER))==0)
		{
			Gewindespindelnmitplanschieber();
			//fprintf(pplog,"\nZurueck aus der Funktion Gewindespindelnmitplanschieber!");
			continue;
		}
		if(strncmp(Kennung,CYCLEAUSSPINDELN,strlen(CYCLEAUSSPINDELN))==0)
		{
			Ausspindeln();
			//fprintf(pplog,"\nZurueck aus der Funktion Ausspindeln!");
			continue;
		}
		if(strncmp(Kennung,CYCLEAUSSPINDELN_MIT_SPINDELSTOP,strlen(CYCLEAUSSPINDELN_MIT_SPINDELSTOP))==0)
		{
			Ausspindelnmitspindelstop();
			//fprintf(pplog,"\nZurueck aus der Funktion Ausspindelnmitspindelstop!");
			continue;
		}
		if(strncmp(Kennung,CYCLEBOHRENMITANFASEN,strlen(CYCLEBOHRENMITANFASEN))==0)
		{
			Bohrenmitanfasen();
			//fprintf(pplog,"\nZurueck aus der Funktion Bohrenmitanfasen!");
			continue;
		}
		if(strncmp(Kennung,CYCLEBEIDSEITIGESANFASEN,strlen(CYCLEBEIDSEITIGESANFASEN))==0)
		{
			Beidseitigesanfasen();
			//fprintf(pplog,"\nZurueck aus der Funktion Beidseitigesanfasen!");
			continue;
		}
		if(strncmp(Kennung,CYCLETNUTFRAESEN,strlen(CYCLETNUTFRAESEN))==0)
		{
			Tnutfraesen();
			//fprintf(pplog,"\nZurueck aus der Funktion Tnutfraesen!");
			continue;
		}
		if(strncmp(Kennung,CYCLERUECKWAERTSAUSSPINDELN,strlen(CYCLERUECKWAERTSAUSSPINDELN))==0)
		{
			Rueckwaertsausspindeln();
			//fprintf(pplog,"\nZurueck aus der Funktion Rueckwaertsausspindeln!");
			continue;
		}
				//Ende der nicht unterstützten Zyklen!!!
		


//************************************************* Z Y K L E N   E N D E *************************************************
//*************************************************************************************************************************

		if((strncmp(Kennung,END,strlen(END))==0)||(strncmp(Kennung,FINI,strlen(FINI))==0))	//Testet nach der END bzw. FINI-Anweisung
		{
			fprintf(nc,"\n");
			iENDE=1;
			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der END / FINI-Überprüfung erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}
		fgets(Rest,99,apt);
		fprintf(nc,"\n***** PROGRAMMFEHLER!!! ***** mit: %s%s",Kennung,Rest);
		fprintf(pplog,"\nFEHLER: UMWANDLUNGSFEHLER MIT KENNUNG: \t%s%s\n",Kennung,Rest);

	}

	rewind(nc);														//Anfangskopf des NC-Programms
	N=1;
	fprintf(nc,"N%ld (PROGRAMMNAME: %s)",N++,pfad);
	fprintf(nc,"\nN%ld (GESAMTANZAHL WERKZEUGWECHSEL: %5.ld)",N++,WWAnzahl);


	fprintf(pplog,"\n\n*******************************************************************************");
	fprintf(pplog,"\nENDE DES PROTOKOLLS");
	fprintf(pplog,"\n*******************************************************************************");


	/********** Ende des eigentlichen Hauptprogramms; alle Dateien schließen... ************/
	if(fclose(apt)==-1)
	{
		fprintf(stderr,"\nFehler beim Schliessen der apt-Datei! ==>Datenverlust moeglich!");
		fprintf(stderr,"\n******************************* AUF WIEDERSEHEN! *******************************\n\n");
		sleep(3);
		exit(-1);
	}
	if(fclose(catialog)==-1)
	{
		fprintf(stderr,"\nFehler beim Schliessen der Catia-Logdatei! ==>Datenverlust moeglich!");
		fprintf(stderr,"\n******************************* AUF WIEDERSEHEN! *******************************\n\n");
		sleep(3);
		exit(-1);
	}
	if(fclose(pplog)==-1)
	{
		fprintf(stderr,"\nFehler beim Schliessen der Log-Datei! ==>Datenverlust moeglich!");
		fprintf(stderr,"\n******************************* AUF WIEDERSEHEN! *******************************\n\n");
		sleep(3);
		exit(-1);
	}
	if(fclose(nc)==-1)
	{
		fprintf(stderr,"\nFehler beim Schliessen der NC-Datei! ==>Datenverlust moeglich!");
		fprintf(stderr,"\n******************************* AUF WIEDERSEHEN! *******************************\n\n");
		sleep(3);
		exit(-1);
	}
	fprintf(stdout,"\n******************************* AUF WIEDERSEHEN! *******************************\n\n");
	sleep(1);

	char systembefehl1[] ="start ";							//Starten der (Ausgabe-) NC-Datei!
	strncat(systembefehl1,ncdatei,strlen(ncdatei));
	system(systembefehl1);

	char systembefehl2[] ="start ";							//Starten der (Ausgabe-) Logdatei!
	strncat(systembefehl2,logdatei,strlen(logdatei));
	system(systembefehl2);


	return 0;
}


void sleep(int zeit)					//Pausenfunktion für eine bestimmte Anzahl von Sekunden
{
	clock_t goal;
	printf("\n");

	goal=(zeit*CLOCKS_PER_SEC)+clock();

	while(goal>clock())
		;
}

void neu(void)							//sucht das Ende einer einzelnen Zykluszeile
{
	char muell='x';
	while(muell!='\n')
	{
		muell=fgetc(apt);
	}
}

void punktaufruf(float Q)
{
	while(1)
	{
		Kontrolle=fscanf(apt,"%s",Kennung);
		if(Kontrolle!=1)
		{
			fprintf(pplog,"\nFEHLER: FEHLER BEIM EINLESEN DER KENNUNG IN punktaufruf()!\n");
			break;
		}

		if(strncmp(Kennung,GOTO,strlen(GOTO))==0)				 //Testet nach einer GOTO-Anweisung
		{
			R=fgetc(apt);
			S=fgetc(apt);
			T=fgetc(apt);
			fscanf(apt,"%f%c%f%c%f",&X,&R,&Y,&S,&Z);
			fprintf(nc,"\nN%ld ",N++);

			if(Zykluszwischentest==0)
			{
				if(X!=ZwischenX)
				{
					fprintf(nc,"X%.3f ",X);
				}
				if(Y!=ZwischenY)
				{
					fprintf(nc,"Y%.3f ",Y);
				}
				if(Z!=ZwischenZ)
				{
					fprintf(nc,"Z%.3f",Z);
				}
			}
			else
			{
				fprintf(nc,"X%.3f Y%.3f Z%.3f",X,Y,Z);
				Zykluszwischentest=0;
			}
			ZwischenX=X;
			ZwischenY=Y;
			ZwischenZ=Z;


			if(((Z+Q)<Zmin)||(ZKontrolle==0))					//forscht nach dem Z-Minimum-Wert
			{
				Zmin=Z+Q;
				ZKontrolle=1; 
			}
			
			if(Z<Zmin)											//für den Sonderfall daß Q positiv ist, stellt die Anfahrebene den tiefsten Punkt dar...
			{
				Zmin=Z;
				ZKontrolle=1; 
			}

			continue;
			fprintf(pplog,"\nC++ FEHLER: Ende der GOTO-Überprüfung in punktaufruf() erreicht!\nPOSTPROZESSORPROGRAMMCODE ÜBERPRÜFEN!\n");
		}

		if(strncmp(Kennung,"CYCLE/OFF",strlen("CYCLE/OFF"))==0)
		{
			Zykluszwischentest=1;
			break;
		}

		fprintf(pplog,"\nFEHLER: Kennung in punktaufruf() kann nicht verarbeitet werden!\n");
		break;
	}
}

void punktaufruf2(void)
{
	while(1)
	{
		Kontrolle=fscanf(apt,"%s",Kennung);
		if(Kontrolle!=1)
		{
			fprintf(pplog,"\nFEHLER: FEHLER BEIM EINLESEN DER KENNUNG IN punktaufruf2()!\n");
			break;
		}
		if(strncmp(Kennung,"CYCLE/OFF",strlen("CYCLE/OFF"))==0)
		{
			break;
		}
	}
}

void Anbohren(void)						//Anbohrzyklus			
{
	float P=0;		//Offset in Z-Richtung auf Sicherheitsebene
	float Q=0;		//Bohrtiefe, gemessen an der Bohrerspitze (bezogen auf Z=0)
	float R=0;		//Niveau der Sicherheitsebene in Z-Richtung (bezogen auf Z=0)
	float L=0;		//Verweilzeit (default=0)
	float F=0;		//Vorschubwert
	char FE[10]="vvvvvvvvv";	//Vorschubeinheit
	neu();
	fscanf(apt,"%f",&L);
	neu();
	fscanf(apt,"%f",&R);
	neu();
	fscanf(apt,"%f",&Q);
	neu();
	fscanf(apt,"%f",&P);
	neu();
	fscanf(apt,"%f",&F);
	neu();
	fgets(FE,10,apt);

	/*fprintf(pplog,"\nVerweilzeit: %f",L);
	fprintf(pplog,"\nNiveau der Sicherheitsebene: %f",R);
	fprintf(pplog,"\nBohrtiefe: %f",Q);
	fprintf(pplog,"\nOffset in Z-Richtung auf die Sicherheitsebene: %f",P);
	fprintf(pplog,"\nVorschubwert: %f",F);
	fprintf(pplog,"\nVorschubeinheit: %s",FE);
	*/

	if (Spindeldrehzahl>5000)
	{
		fprintf(pplog,"\nACHTUNG: HOHE DREHZAHL BEIM ZENTRIEREN: S=%.f\n",Spindeldrehzahl);
	}

	if(strncmp(FE,"MMPR,\n",strlen(FE))==0)
	{
		F=F*Spindeldrehzahl;
	}
	if(F>VORSCHUBMAX)
	{
		F=VORSCHUBMAX;
	}

	Q=-Q;
	fprintf(nc,"\nN%ld G81 P%.3f Q%.3f R%.3f L%.1f F%.f",N++,P,Q,R,L,F);
	punktaufruf(Q);
	fprintf(nc,"\nN%ld G80",N++);
}

void Bohren(void)						//normaler Bohrzyklus - Bohrung wird ohne Spanbruch und ohne Verweilzeit erzeugt!			
{
	float P=0;		//Offset in Z-Richtung auf Sicherheitsebene
	float Q=0;		//Bohrtiefe, gemessen an der Bohrerspitze (bezogen auf Z=0)
	float R=0;		//Niveau der Sicherheitsebene in Z-Richtung (bezogen auf Z=0)
	float F=0;		//Vorschubwert
	char FE[10]="vvvvvvvvv";	//Vorschubeinheit
	neu();
	fscanf(apt,"%f",&R);
	neu();
	fscanf(apt,"%f",&Q);
	neu();
	fscanf(apt,"%f",&P);
	neu();
	fscanf(apt,"%f",&F);
	neu();
	fgets(FE,10,apt);

	/*fprintf(pplog,"\nNiveau der Sicherheitsebene: %f",R);
	fprintf(pplog,"\nBohrtiefe: %f",Q);
	fprintf(pplog,"\nOffset in Z-Richtung auf die Sicherheitsebene: %f",P);
	fprintf(pplog,"\nVorschubwert: %f",F);
	fprintf(pplog,"\nVorschubeinheit: %s",FE);
	*/
	

	if (Spindeldrehzahl>5000)
	{
		fprintf(pplog,"\nACHTUNG: HOHE DREHZAHL BEIM BOHREN: S=%.f\n",Spindeldrehzahl);
	}

	if(strncmp(FE,"MMPR,\n",strlen(FE))==0)
	{
		F=F*Spindeldrehzahl;
	}
	if(F>VORSCHUBMAX)
	{
		F=VORSCHUBMAX;
	}

	Q=-Q;
	fprintf(nc,"\nN%ld G81 P%.3f Q%.3f R%.3f F%.f",N++,P,Q,R,F);
	punktaufruf(Q);
	fprintf(nc,"\nN%ld G80",N++);
}

void BohrenmitVerweilzeit(void)						//Bohren mit Verweilzeitzyklus			
{
	float P=0;		//Offset in Z-Richtung auf Sicherheitsebene
	float Q=0;		//Bohrtiefe, gemessen an der Bohrerspitze (bezogen auf Z=0)
	float R=0;		//Niveau der Sicherheitsebene in Z-Richtung (bezogen auf Z=0)
	float L=0;		//Verweilzeit (default=0)
	float F=0;		//Vorschubwert
	char FE[10]="vvvvvvvvv";	//Vorschubeinheit
	neu();
	fscanf(apt,"%f",&L);
	neu();
	fscanf(apt,"%f",&R);
	neu();
	fscanf(apt,"%f",&Q);
	neu();
	fscanf(apt,"%f",&P);
	neu();
	fscanf(apt,"%f",&F);
	neu();
	fgets(FE,10,apt);

	/*fprintf(pplog,"\nVerweilzeit: %f",L);
	fprintf(pplog,"\nNiveau der Sicherheitsebene: %f",R);
	fprintf(pplog,"\nBohrtiefe: %f",Q);
	fprintf(pplog,"\nOffset in Z-Richtung auf die Sicherheitsebene: %f",P);
	fprintf(pplog,"\nVorschubwert: %f",F);
	fprintf(pplog,"\nVorschubeinheit: %s",FE);
	*/

	if (Spindeldrehzahl>5000)
	{
		fprintf(pplog,"\nACHTUNG: HOHE DREHZAHL BEIM ZYKLUS: BOHREN MIT VERWEILZEIT: S=%.f\n",Spindeldrehzahl);
	}

	if(strncmp(FE,"MMPR,\n",strlen(FE))==0)
	{
		F=F*Spindeldrehzahl;
	}
	if(F>VORSCHUBMAX)
	{
		F=VORSCHUBMAX;
	}

	Q=-Q;
	fprintf(nc,"\nN%ld G81 P%.3f Q%.3f R%.3f L%.1f F%.f",N++,P,Q,R,L,F);
	punktaufruf(Q);
	fprintf(nc,"\nN%ld G80",N++);
}

void BohrenmitSpanbruch(void)						//Bohren mit Spanbruch			
{
	float P=0;		//Offset in Z-Richtung auf Sicherheitsebene
	float Q=0;		//Bohrtiefe, gemessen an der Bohrerspitze (bezogen auf Z=0)
	float R=0;		//Niveau der Sicherheitsebene in Z-Richtung (bezogen auf Z=0)
	float L=0;		//Verweilzeit (default=0)
	float F=0;		//Vorschubwert
	float I=0;		//Rückzug vom Lochgrund (relativ, default=1mm)
	float K=0;		//Bohrweg bis Rückzug (relativ, default=5mm)
	char FE[10]="vvvvvvvvv";	//Vorschubeinheit

	neu();
	fscanf(apt,"%f",&L);
	neu();
	fscanf(apt,"%f",&R);
	neu();
	fscanf(apt,"%f",&Q);
	neu();
	fscanf(apt,"%f",&P);
	neu();
	fscanf(apt,"%f",&F);
	neu();
	fgets(FE,10,apt);
	fscanf(apt,"%f",&K);
	neu();
	fscanf(apt,"%f",&I);
	neu();

	/*fprintf(pplog,"\nVerweilzeit: %f",L);
	fprintf(pplog,"\nNiveau der Sicherheitsebene: %f",R);
	fprintf(pplog,"\nBohrtiefe: %f",Q);
	fprintf(pplog,"\nOffset in Z-Richtung auf die Sicherheitsebene: %f",P);
	fprintf(pplog,"\nVorschubwert: %f",F);
	fprintf(pplog,"\nVorschubeinheit: %s",FE);
	fprintf(pplog,"\nBohrweg bis Rueckzug: %f",K);
	fprintf(pplog,"\nRückzug vom Lochgrund: %f",I);*/
	

	if (Spindeldrehzahl>5000)
	{
		fprintf(pplog,"\nACHTUNG: HOHE DREHZAHL BEIM ZYKLUS: BOHREN MIT SPANBRUCH: S=%.f\n",Spindeldrehzahl);
	}

	if(strncmp(FE,"MMPR,\n",strlen(FE))==0)
	{
		F=F*Spindeldrehzahl;
	}
	if(F>VORSCHUBMAX)
	{
		F=VORSCHUBMAX;
	}

	Q=-Q;
	fprintf(nc,"\nN%ld G82 I%.3f K%.3f P%.3f Q%.3f R%.3f L%.1f F%.f",N++,I,K,P,Q,R,L,F);
	punktaufruf(Q);
	fprintf(nc,"\nN%ld G80",N++);
}

void Tieflochbohren(void)						//Tieflochbohren			
{
	float P=0;		//Offset in Z-Richtung auf Sicherheitsebene
	float Q=0;		//Bohrtiefe, gemessen an der Bohrerspitze (bezogen auf Z=0)
	float R=0;		//Niveau der Sicherheitsebene in Z-Richtung (bezogen auf Z=0)
	float L=0;		//Verweilzeit (default=0)
	float F=0;		//Vorschubwert
	float I=0;		//Rückzug vom Lochgrund (relativ, default=1mm)
	float K=0;		//Bohrweg bis Rückzug (relativ, default=5mm)
	char FE[10]="vvvvvvvvv";	//Vorschubeinheit

	neu();
	fscanf(apt,"%f",&L);
	neu();
	fscanf(apt,"%f",&R);
	neu();
	fscanf(apt,"%f",&Q);
	neu();
	fscanf(apt,"%f",&P);
	neu();
	fscanf(apt,"%f",&F);
	neu();
	fgets(FE,10,apt);
	fscanf(apt,"%f",&K);
	neu();
	fscanf(apt,"%f",&I);
	neu();

	/*fprintf(pplog,"\nVerweilzeit: %f",L);
	fprintf(pplog,"\nNiveau der Sicherheitsebene: %f",R);
	fprintf(pplog,"\nBohrtiefe: %f",Q);
	fprintf(pplog,"\nOffset in Z-Richtung auf die Sicherheitsebene: %f",P);
	fprintf(pplog,"\nVorschubwert: %f",F);
	fprintf(pplog,"\nVorschubeinheit: %s",FE);
	fprintf(pplog,"\nBohrweg bis Rueckzug: %f",K);
	fprintf(pplog,"\nRückzug vom Lochgrund: %f",I);*/
	

	if (Spindeldrehzahl>5000)
	{
		fprintf(pplog,"\nACHTUNG: HOHE DREHZAHL BEIM ZYKLUS: TIEFLOCHBOHREN: S=%.f\n",Spindeldrehzahl);
	}

	if(strncmp(FE,"MMPR,\n",strlen(FE))==0)
	{
		F=F*Spindeldrehzahl;
	}
	if(F>VORSCHUBMAX)
	{
		F=VORSCHUBMAX;
	}

	Q=-Q;
	fprintf(nc,"\nN%ld G83 I%.3f K%.3f P%.3f Q%.3f R%.3f L%.1f F%.f",N++,I,K,P,Q,R,L,F);
	punktaufruf(Q);
	fprintf(nc,"\nN%ld G80",N++);
}

void Rechtsgewinde(void)						//Zyklus für ein Rechtsgewinde			
{
	float P=0;		//Offset in Z-Richtung auf Sicherheitsebene
	float Q=0;		//Bohrtiefe, gemessen an der Bohrerspitze (bezogen auf Z=0)
	float R=0;		//Niveau der Sicherheitsebene in Z-Richtung (bezogen auf Z=0)
	float F=0;		//Vorschubwert
	char FE[10]="vvvvvvvvv";	//Vorschubeinheit

	neu();
	fscanf(apt,"%f",&R);
	neu();
	fscanf(apt,"%f",&Q);
	neu();
	fscanf(apt,"%f",&P);
	neu();
	fscanf(apt,"%f",&F);
	neu();
	fgets(FE,10,apt);

	/*fprintf(pplog,"\nNiveau der Sicherheitsebene: %f",R);
	fprintf(pplog,"\nBohrtiefe: %f",Q);
	fprintf(pplog,"\nOffset in Z-Richtung auf die Sicherheitsebene: %f",P);
	fprintf(pplog,"\nVorschubwert: %f",F);
	fprintf(pplog,"\nVorschubeinheit: %s",FE);
	*/

	if (Spindeldrehzahl>200)
	{
		fprintf(pplog,"\nACHTUNG: HOHE DREHZAHL BEIM RECHTSGEWINDEBOHREN: S=%.f\n",Spindeldrehzahl);
	}

	if(strncmp(FE,"MMPR,\n",strlen(FE))==0)
	{
		F=F*Spindeldrehzahl;
	}
	if(F>VORSCHUBMAX)
	{
		fprintf(pplog,"\nACHTUNG: GEWUENSCHTER VORSCHUB HOEHER ALS MASCHINELL MOEGLICH BEIM RECHTSGEWINDEZYKLUS: F=%.f\n",F);
	}

	Q=-Q;
	fprintf(nc,"\nN%ld G84 P%.3f Q%.3f R%.3f F%.3f",N++,P,Q,R,F);
	punktaufruf(Q);
	fprintf(nc,"\nN%ld G80",N++);
}
void Linksgewinde(void)						//Zyklus für ein Linksgewinde			
{
	float P=0;		//Offset in Z-Richtung auf Sicherheitsebene
	float Q=0;		//Bohrtiefe, gemessen an der Bohrerspitze (bezogen auf Z=0)
	float R=0;		//Niveau der Sicherheitsebene in Z-Richtung (bezogen auf Z=0)
	float F=0;		//Vorschubwert
	char FE[10]="vvvvvvvvv";	//Vorschubeinheit

	neu();
	fscanf(apt,"%f",&R);
	neu();
	fscanf(apt,"%f",&Q);
	neu();
	fscanf(apt,"%f",&P);
	neu();
	fscanf(apt,"%f",&F);
	neu();
	fgets(FE,10,apt);

	/*fprintf(pplog,"\nNiveau der Sicherheitsebene: %f",R);
	fprintf(pplog,"\nBohrtiefe: %f",Q);
	fprintf(pplog,"\nOffset in Z-Richtung auf die Sicherheitsebene: %f",P);
	fprintf(pplog,"\nVorschubwert: %f",F);
	fprintf(pplog,"\nVorschubeinheit: %s",FE);
	*/

	if (Spindeldrehzahl>200)
	{
		fprintf(pplog,"\nACHTUNG: HOHE DREHZAHL BEIM LINKSGEWINDEBOHREN: S=%.f\n",Spindeldrehzahl);
	}

	if(strncmp(FE,"MMPR,\n",strlen(FE))==0)
	{
		F=F*Spindeldrehzahl;
	}
	if(F>VORSCHUBMAX)
	{
		fprintf(pplog,"\nACHTUNG: GEWUENSCHTER VORSCHUB HOEHER ALS MASCHINELL MOEGLICH BEIM LINKSGEWINDEZYKLUS: F=%.f\n",F);
	}

	Q=-Q;
	fprintf(nc,"\nN%ld G84 P%.3f Q%.3f R%.3f M4 F%.3f",N++,P,Q,R,F);
	punktaufruf(Q);
	fprintf(nc,"\nN%ld G80",N++);
}
void Reiben(void)						//Reibzyklus			
{
	float P=0;		//Offset in Z-Richtung auf Sicherheitsebene
	float Q=0;		//Bohrtiefe, gemessen an der Bohrerspitze (bezogen auf Z=0)
	float R=0;		//Niveau der Sicherheitsebene in Z-Richtung (bezogen auf Z=0)
	float L=0;		//Verweilzeit (default=0)
	float F=0;		//Vorschubwert
	char FE[10]="vvvvvvvvv";	//Vorschubeinheit
	neu();
	fscanf(apt,"%f",&L);
	neu();
	fscanf(apt,"%f",&R);
	neu();
	fscanf(apt,"%f",&Q);
	neu();
	fscanf(apt,"%f",&P);
	neu();
	fscanf(apt,"%f",&F);
	neu();
	fgets(FE,10,apt);

	/*fprintf(pplog,"\nVerweilzeit: %f",L);
	fprintf(pplog,"\nNiveau der Sicherheitsebene: %f",R);
	fprintf(pplog,"\nBohrtiefe: %f",Q);
	fprintf(pplog,"\nOffset in Z-Richtung auf die Sicherheitsebene: %f",P);
	fprintf(pplog,"\nVorschubwert: %f",F);
	fprintf(pplog,"\nVorschubeinheit: %s",FE);
	*/

	if (Spindeldrehzahl>500)
	{
		fprintf(pplog,"\nACHTUNG: HOHE DREHZAHL BEIM REIBEN: S=%.f\n",Spindeldrehzahl);
	}

	if(strncmp(FE,"MMPR,\n",strlen(FE))==0)
	{
		F=F*Spindeldrehzahl;
	}
	if(F>VORSCHUBMAX)
	{
		F=VORSCHUBMAX;
	}
	if(F>1000)
	{
		fprintf(pplog,"\nACHTUNG: HOHER VORSCHUB BEIM REIBEN: F=%.f\n",F);
	}

	Q=-Q;
	fprintf(nc,"\nN%ld G85 P%.3f Q%.3f R%.3f L%.1f F%.f",N++,P,Q,R,L,F);
	punktaufruf(Q);
	fprintf(nc,"\nN%ld G80",N++);
}
void Planeinsenken(void)						//Planeinsenkzyklus (Km-Senkungen)			
{
	float P=0;		//Offset in Z-Richtung auf Sicherheitsebene
	float Q=0;		//Bohrtiefe, gemessen an der Bohrerspitze (bezogen auf Z=0)
	float R=0;		//Niveau der Sicherheitsebene in Z-Richtung (bezogen auf Z=0)
	float L=0;		//Verweilzeit (default=0)
	float F=0;		//Vorschubwert
	char FE[10]="vvvvvvvvv";	//Vorschubeinheit
	neu();
	fscanf(apt,"%f",&L);
	neu();
	fscanf(apt,"%f",&R);
	neu();
	fscanf(apt,"%f",&Q);
	neu();
	fscanf(apt,"%f",&P);
	neu();
	fscanf(apt,"%f",&F);
	neu();
	fgets(FE,10,apt);

	/*fprintf(pplog,"\nVerweilzeit: %f",L);
	fprintf(pplog,"\nNiveau der Sicherheitsebene: %f",R);
	fprintf(pplog,"\nBohrtiefe: %f",Q);
	fprintf(pplog,"\nOffset in Z-Richtung auf die Sicherheitsebene: %f",P);
	fprintf(pplog,"\nVorschubwert: %f",F);
	fprintf(pplog,"\nVorschubeinheit: %s",FE);
	*/

	if (Spindeldrehzahl>500)
	{
		fprintf(pplog,"\nACHTUNG: HOHE DREHZAHL BEIM PLANEINSENKEN: S=%.f\n",Spindeldrehzahl);
	}

	if(strncmp(FE,"MMPR,\n",strlen(FE))==0)
	{
		F=F*Spindeldrehzahl;
	}
	if(F>VORSCHUBMAX)
	{
		F=VORSCHUBMAX;
	}
	if(F>200)
	{
		fprintf(pplog,"\nACHTUNG: HOHER VORSCHUB BEIM PLANEINSENKEN	: F=%.f\n",F);
	}

	Q=-Q;
	fprintf(nc,"\nN%ld G83 P%.3f Q%.3f R%.3f L%.1f F%.f",N++,P,Q,R,L,F);
	punktaufruf(Q);
	fprintf(nc,"\nN%ld G80",N++);
}
void Profileinsenken(void)						//Profileinsenkzyklus (90°-Senkungen)			
{
	float P=0;		//Offset in Z-Richtung auf Sicherheitsebene
	float Q=0;		//Bohrtiefe, gemessen an der Bohrerspitze (bezogen auf Z=0)
	float R=0;		//Niveau der Sicherheitsebene in Z-Richtung (bezogen auf Z=0)
	float L=0;		//Verweilzeit (default=0)
	float F=0;		//Vorschubwert
	char FE[10]="vvvvvvvvv";	//Vorschubeinheit
	neu();
	fscanf(apt,"%f",&L);
	neu();
	fscanf(apt,"%f",&R);
	neu();
	fscanf(apt,"%f",&Q);
	neu();
	fscanf(apt,"%f",&P);
	neu();
	fscanf(apt,"%f",&F);
	neu();
	fgets(FE,10,apt);

	/*fprintf(pplog,"\nVerweilzeit: %f",L);
	fprintf(pplog,"\nNiveau der Sicherheitsebene: %f",R);
	fprintf(pplog,"\nBohrtiefe: %f",Q);
	fprintf(pplog,"\nOffset in Z-Richtung auf die Sicherheitsebene: %f",P);
	fprintf(pplog,"\nVorschubwert: %f",F);
	fprintf(pplog,"\nVorschubeinheit: %s",FE);
	*/

	if (Spindeldrehzahl>500)
	{
		fprintf(pplog,"\nACHTUNG: HOHE DREHZAHL BEIM PROFILEINSENKEN: S=%.f\n",Spindeldrehzahl);
	}

	if(strncmp(FE,"MMPR,\n",strlen(FE))==0)
	{
		F=F*Spindeldrehzahl;
	}
	if(F>VORSCHUBMAX)
	{
		F=VORSCHUBMAX;
	}
	if(F>200)
	{
		fprintf(pplog,"\nACHTUNG: HOHER VORSCHUB BEIM PROFILEINSENKEN	: F=%.f\n",F);
	}

	Q=-Q;
	fprintf(nc,"\nN%ld G83 P%.3f Q%.3f R%.3f L%.1f F%.f",N++,P,Q,R,L,F);
	punktaufruf(Q);
	fprintf(nc,"\nN%ld G80",N++);
}

//*****Anfang der nicht unterstütze Zyklen!!!*****

void Rueckwaertsausspindeln(void)								
{
	//neu();
	fprintf(pplog,"\nFEHLER: ZYKLUS RUECKWAERTSAUSSPINDELN WIRD NICHT UNTERSTUETZT!!!\n");
	punktaufruf2();

}
void Tnutfraesen(void)							
{
	//neu();
	fprintf(pplog,"\nFEHLER: ZYKLUS T-NUTFRAESEN WIRD NICHT UNTERSTUETZT!!!\n");
	punktaufruf2();
}
void Beidseitigesanfasen(void)								
{
	//neu();
	fprintf(pplog,"\nFEHLER: ZYKLUS BEIDSEITIGES ANFASEN WIRD NICHT UNTERSTUETZT!!!\n");
	punktaufruf2();
}
void Bohrenmitanfasen(void)							
{
	//neu();
	fprintf(pplog,"\nFEHLER: ZYKLUS BOHREN MIT ANFASEN WIRD NICHT UNTERSTUETZT!!!\n");
	punktaufruf2();
}
void Gewindespindelnmitplanschieber(void)							
{
	//neu();
	fprintf(pplog,"\nFEHLER: ZYKLUS GEWINDESPINDELN MIT PLANSCHIEBER WIRD NICHT UNTERSTUETZT!!!\n");
	punktaufruf2();
}
void Ausspindeln(void)								
{
	//neu();
	fprintf(pplog,"\nFEHLER: ZYKLUS AUSSPINDELN WIRD NICHT UNTERSTUETZT!!!\n");
	punktaufruf2();
}
void Ausspindelnmitspindelstop(void)							
{
	//neu();
	fprintf(pplog,"\nFEHLER: ZYKLUS AUSSPINDELN MIT SPINDELSTOP WIRD NICHT UNTERSTUETZT!!!\n");
	punktaufruf2();
}