/*
	Zeichen einer Datei durch Zufallszahlen ersetzen.

	Dieses Programm ersetzt alle gefundenen "Marker-Zeichen" durch eine Zufalls-Zahl.
	Gedacht war dieses Programm, um in POV-/ASCII-Dateien zufallswerte einzusetzen.


	Man kann bis zu 3 Zeichen gleichzeitig ersetzen.

	Die Marker (-m/-n/-o) duerfen dabei nur aus einem Zeichen bestehen.
	Achten Sie darauf, dass die Marker in der Quelldatei nur an den Stellen vorkommen,
	die auch ersetzt werden sollen.


	Die Bereiche werden mit 1 oder 2 Werten angegeben (-1/-3/-5 und -2/-4/-6)
	Sie koennen fuer fuer jeden Bereich auch einen Teiler (-t/-u/-v) angeben,
	um Kommazahlen zu erzeugen.
	Die Bedeutung der Werte ist:
		rand()% ( wert1 + wert2 ) / teiler1
	z.B.
		z2z -1 1000 -2 -500
		erzeugt Zufallszahlen im Bereich von -500 bis 499.
		z2z -1 1000 -2 -500 -t 10
		erzeugt Zufallszahlen im Bereich von -50.0 bis 49.9.
	Der zweite Wert (-2/-4/-6) kann weggelassen werden.
	z.B.
		z2z -1 1000
		erzeugt Zufallszahlen im Bereich von 0 bis 999.
		z2z -1 1000 -t 10
		erzeugt Zufallszahlen im Bereich von 0 bis 99.9.
*/



#define DEBUG true


char VERSION[10]={"0.20"};



#include <stdlib.h>
#include <getopt.h>
#include <fstream>
#include <string.h>
#include <math.h>

#include <fcntl.h>
#include <unistd.h>

int urandom_fd = -2;


// Typen -------------------------------------------------------------------------------------------
struct option opts[]={
      {"quelldatei",      required_argument,0,  'q'},
      {"zieldatei",       required_argument,0,  'z'},

      {"marker1",         required_argument,0,  'm'},
      {"bereich1",        required_argument,0,  '1'},
      {"bereich2",        required_argument,0,  '2'},
      {"teiler1",         required_argument,0,  't'},
      {"marker2",         required_argument,0,  'n'},
      {"bereich3",        required_argument,0,  '3'},
      {"bereich4",        required_argument,0,  '4'},
      {"teiler2",         required_argument,0,  'u'},
      {"marker3",         required_argument,0,  'o'},
      {"bereich5",        required_argument,0,  '5'},
      {"bereich6",        required_argument,0,  '6'},
      {"teiler3",         required_argument,0,  'v'},

      {"markerR",         required_argument,0,  'M'},
      {"radiusX",         required_argument,0,  'X'},
      {"radius_minX",     required_argument,0,  'A'},
      {"teilerX",         required_argument,0,  'T'},
      {"radiusY",         required_argument,0,  'Y'},
      {"radius_minY",     required_argument,0,  'B'},
      {"teilerY",         required_argument,0,  'U'},
      {"radiusZ",         required_argument,0,  'Z'},
      {"radius_minZ",     required_argument,0,  'C'},
      {"teilerZ",         required_argument,0,  'V'},
      {"help",            no_argument,      0,  'h'},
      {0,                 0,                0,    0}
};





// Globales ----------------------------------------------------------------------------------------
const int max_zeilenlaenge=1024;
char quellname[max_zeilenlaenge]={""};
char zielname[max_zeilenlaenge]={""};

char marker1[max_zeilenlaenge]={""};
char bereich1[max_zeilenlaenge]={""};
char bereich2[max_zeilenlaenge]={""};
char teiler1[max_zeilenlaenge]={""};

char marker2[max_zeilenlaenge]={""};
char bereich3[max_zeilenlaenge]={""};
char bereich4[max_zeilenlaenge]={""};
char teiler2[max_zeilenlaenge]={""};

char marker3[max_zeilenlaenge]={""};
char bereich5[max_zeilenlaenge]={""};
char bereich6[max_zeilenlaenge]={""};
char teiler3[max_zeilenlaenge]={""};

char markerR[max_zeilenlaenge]={""};
char radiusX[max_zeilenlaenge]={""};
char radius_minX[max_zeilenlaenge]={""};
char teilerX[max_zeilenlaenge]={""};

char radiusY[max_zeilenlaenge]={""};
char radius_minY[max_zeilenlaenge]={""};
char teilerY[max_zeilenlaenge]={""};

char radiusZ[max_zeilenlaenge]={""};
char radius_minZ[max_zeilenlaenge]={""};
char teilerZ[max_zeilenlaenge]={""};


const double Pi=3.14159265358979323846264338327950288419716939937510582097494459230781640628620899;




// Funktionen --------------------------------------------------------------------------------------
void Bedienung();
/*
void urandom_init()
unsigned long urandom();
*/
void test();

float MyRandom( float Bereich );





// Hauptprogramm ###################################################################################
int main(int argc, char *argv[])
{
//test();
	bool stdout=true;

	if(argc==1){Bedienung();}

	int optc=0;
	while((optc=getopt_long(argc,argv,"q:z:m:1:2:t:n:3:4:u:o:5:6:v:M:X:A:T:N:Y:B:U:O:Z:C:V:h",opts,NULL))!=EOF)
	{
		switch(optc)
		{
// Quelldatei
			case'q':
				strncat(quellname,optarg,max_zeilenlaenge-1);
			break;
// Zieldatei
			case'z':
				strncat(zielname,optarg,max_zeilenlaenge-1);
				stdout=false;
			break;


// Marker1
			case'm':
				strncat(marker1,optarg,max_zeilenlaenge-1);
				if(strlen(marker1)!=1)
				{
					printf("\aDer Marker 1 muss aus EINEM Zeichen Bestehen! >%s<\n",marker1);
					exit(1);
				}
			break;
// Bereich 1
			case'1':
				strncat(bereich1,optarg,max_zeilenlaenge-1);
				if(atoi(bereich1)==0)
				{
					printf("\aDer Bereich 1 ist fehlerhaft! >%s<\n",bereich1);
					exit(1);
				}
			break;
// Bereich 2
			case'2':
				strncat(bereich2,optarg,max_zeilenlaenge-1);
				if(atoi(bereich2)==0)
				{
					printf("\aDer Bereich 2 ist fehlerhaft! >%s<\n",bereich2);
					exit(1);
				}
			break;
// Teiler 1
			case't':
				strncat(teiler1,optarg,max_zeilenlaenge-1);
				if(atoi(teiler1)==0)
				{
					printf("\aDer Teiler 1 ist fehlerhaft! >%s<\n",teiler1);
					exit(1);
				}
			break;


// Marker2
			case'n':
				strncat(marker2,optarg,max_zeilenlaenge-1);
				if(strlen(marker2)!=1)
				{
					printf("\aDer Marker 2 muss aus EINEM Zeichen Bestehen! >%s<\n",marker2);
					exit(1);
				}
			break;
// Bereich 3
			case'3':
				strncat(bereich3,optarg,max_zeilenlaenge-1);
				if(atoi(bereich3)==0)
				{
					printf("\aDer Bereich 3 ist fehlerhaft! >%s<\n",bereich3);
					exit(1);
				}
			break;
// Bereich 4
			case'4':
				strncat(bereich4,optarg,max_zeilenlaenge-1);
				if(atoi(bereich4)==0)
				{
					printf("\aDer Bereich 4 ist fehlerhaft! >%s<\n",bereich4);
					exit(1);
				}
			break;
// Teiler 2
			case'u':
				strncat(teiler2,optarg,max_zeilenlaenge-1);
				if(atoi(teiler2)==0)
				{
					printf("\aDer Teiler 2 ist fehlerhaft! >%s<\n",teiler2);
					exit(1);
				}
			break;


// Marker3
			case'o':
				strncat(marker3,optarg,max_zeilenlaenge-1);
				if(strlen(marker3)!=1)
				{
					printf("\aDer Marker 3 muss aus EINEM Zeichen Bestehen! >%s<\n",marker3);
					exit(1);
				}
			break;
// Bereich 5
			case'5':
				strncat(bereich5,optarg,max_zeilenlaenge-1);
				if(atoi(bereich5)==0)
				{
					printf("\aDer Bereich 5 ist fehlerhaft! >%s<\n",bereich5);
					exit(1);
				}
			break;
// Bereich 6
			case'6':
				strncat(bereich6,optarg,max_zeilenlaenge-1);
				if(atoi(bereich6)==0)
				{
					printf("\aDer Bereich 6 ist fehlerhaft! >%s<\n",bereich6);
					exit(1);
				}
			break;
// Teiler 3
			case'v':
				strncat(teiler3,optarg,max_zeilenlaenge-1);
				if(atoi(teiler3)==0)
				{
					printf("\aDer Teiler 3 ist fehlerhaft! >%s<\n",teiler3);
					exit(1);
				}
			break;


// Marker R
			case'M':
				strncat(markerR,optarg,max_zeilenlaenge-1);
				if(strlen(markerR)!=1)
				{
					printf("\aDer Marker R muss aus EINEM Zeichen Bestehen! >%s<\n",markerR);
					exit(1);
				}
			break;
// Radius X
			case'X':
				strncat(radiusX,optarg,max_zeilenlaenge-1);
				if(atoi(radiusX)==0)
				{
					printf("\aDer Radius X ist fehlerhaft! >%s<\n",radiusX);
					exit(1);
				}
			break;
// Radius X min
			case'A':
				strncat(radius_minX,optarg,max_zeilenlaenge-1);
				if(atoi(radius_minX)==0||atoi(radius_minX)>=atoi(radiusX))
				{
					printf("\aDer Min.Radius X ist fehlerhaft! >%s<\n",radius_minX);
					exit(1);
				}
			break;
// Teiler X
			case'T':
				strncat(teilerX,optarg,max_zeilenlaenge-1);
				if(atoi(teilerX)==0)
				{
					printf("\aDer Teiler X ist fehlerhaft! >%s<\n",teilerX);
					exit(1);
				}
			break;


// Radius Y
			case'Y':
				strncat(radiusY,optarg,max_zeilenlaenge-1);
				if(atoi(radiusY)==0)
				{
					printf("\aDer Radius Y ist fehlerhaft! >%s<\n",radiusY);
					exit(1);
				}
			break;
// Radius Y min
			case'B':
				strncat(radius_minY,optarg,max_zeilenlaenge-1);
				if(atoi(radius_minY)==0||atoi(radius_minY)>=atoi(radiusY))
				{
					printf("\aDer Min.Radius Y ist fehlerhaft! >%s<\n",radius_minY);
					exit(1);
				}
			break;
// Teiler Y
			case'U':
				strncat(teilerY,optarg,max_zeilenlaenge-1);
				if(atoi(teilerY)==0)
				{
					printf("\aDer Teiler Y ist fehlerhaft! >%s<\n",teilerY);
					exit(1);
				}
			break;


// Radius Z
			case'Z':
				strncat(radiusZ,optarg,max_zeilenlaenge-1);
				if(atoi(radiusZ)==0)
				{
					printf("\aDer Radius Z ist fehlerhaft! >%s<\n",radiusZ);
					exit(1);
				}
			break;
// Radius Z min
			case'C':
				strncat(radius_minZ,optarg,max_zeilenlaenge-1);
				if(atoi(radius_minZ)==0||atoi(radius_minZ)>=atoi(radiusZ))
				{
					printf("\aDer Min.Radius Z ist fehlerhaft! >%s<\n",radius_minZ);
					exit(1);
				}
			break;
// Teiler Z
			case'V':
				strncat(teilerZ,optarg,max_zeilenlaenge-1);
				if(atoi(teilerZ)==0)
				{
					printf("\aDer Teiler Z ist fehlerhaft! >%s<\n",teilerZ);
					exit(1);
				}
			break;


// Fehlermeldung
			default:
				printf("\a\nVerwenden Sie z2z --help fuer Hilfe!\n\n");
				exit(1);
			break;
// Hilfe
			case'h':
				Bedienung();
			break;
		}
	}





//printf("---------------->%s%s< >%i + %i<\n",bereich1,bereich2,atoi(bereich1),atoi(bereich2));

#if DEBUG
	fprintf(stderr,"Quelldatei >%s<\nZieldatei >%s<\n",quellname,(strlen(zielname)>0)?zielname:"stdout");
	if(strlen(marker1)>0)
	{
		fprintf(stderr,"Marker 1 >%s<\nBereich >%s %s%s%s<\n",marker1,bereich1,bereich2,(strlen(teiler1)>0)?" / ":"",(strlen(teiler1)>0)?teiler1:"");
	}
	if(strlen(marker2)>0)
	{
		fprintf(stderr,"Marker 2 >%s<\nBereich >%s %s%s%s<\n",marker2,bereich3,bereich4,(strlen(teiler2)>0)?" / ":"",(strlen(teiler2)>0)?teiler2:"");
	}
	if(strlen(marker3)>0)
	{
		fprintf(stderr,"Marker 3 >%s<\nBereich >%s %s%s%s<\n",marker3,bereich5,bereich6,(strlen(teiler3)>0)?" / ":"",(strlen(teiler3)>0)?teiler3:"");
	}

	if(strlen(markerR)>0)
	{
		fprintf(stderr,"Marker R >%s<\nRadius X >%s %s%s%s<\n",markerR,radiusX,radius_minX,(strlen(teilerX)>0)?" / ":"",(strlen(teilerX)>0)?teilerX:"");
		if(strlen(radiusY)>0)
		{
			fprintf(stderr,"Marker R >%s<\nRadius Y >%s %s%s%s<\n",markerR,radiusY,radius_minY,(strlen(teilerY)>0)?" / ":"",(strlen(teilerY)>0)?teilerY:"");
		}
		if(strlen(radiusZ)>0)
		{
			fprintf(stderr,"Marker R >%s<\nRadius Z >%s %s%s%s<\n",markerR,radiusZ,radius_minZ,(strlen(teilerZ)>0)?" / ":"",(strlen(teilerZ)>0)?teilerZ:"");
		}
	}
#endif



// Zufalls-Seed start
	srandom(time(0));




// Datei bearbeiten.
#if DEBUG
	fprintf(stderr,"Textdatei \"%s\" einlesen...\n",quellname);
#endif


// File-Handler erzeugen
// Quelldatei
	std::ifstream load(quellname,std::ios::in);
	if(load==NULL)
  {
  	fprintf(stderr,"\a>%s< konnte nicht geoeffnet werden!\n",quellname);
		exit(1);
  }

// Zieldatei
	std::fstream save;
	if(!stdout)
	{
		save.open(zielname,std::ios::out);
		if(save==NULL)
		{
  		fprintf(stderr,"\akonnte >%s< nicht anlegen!\n",zielname);
			exit(1);
		}
	}




// Datei nach >Marker< durchsuchen und >Marker< ersetzen.
#if DEBUG
	fprintf(stderr,"Lese >%s<\nSchreibe >%s<\n",quellname,stdout?"stdout":zielname);
#endif


	char Z;
	while(!load.eof())
	{
// Laden
		load.get(Z);


// Speichern
		if(!stdout)
		{
// in Datei
			if(Z==marker1[0])
			{
				if(atoi(teiler1)>1)
				{
					save<<(float)(rand()%atoi(bereich1) + atoi(bereich2)) / atoi(teiler1);
				}
				else
				{
					save<<rand()%atoi(bereich1) + atoi(bereich2);
				}
			}
			else if(Z==marker2[0])
			{
				if(atoi(teiler2)>1)
				{
					save<<(float)(rand()%atoi(bereich3) + atoi(bereich4)) / atoi(teiler2);
				}
				else
				{
					save<<rand()%atoi(bereich3) + atoi(bereich4);
				}
			}
			else if(Z==marker3[0])
			{
				if(atoi(teiler3)>1)
				{
					save<<(float)(rand()%atoi(bereich5) + atoi(bereich6)) / atoi(teiler3);
				}
				else
				{
					save<<rand()%atoi(bereich5) + atoi(bereich6);
				}
			}

/*			else if(Z==markerR[0])
			{
				float winkel=MyRandom(360.0);
				float winkelZ=MyRandom(360.0);

				int radX=atoi(radiusX)-atoi(radius_minX);
				if(radX<1){radX=1;}
				int radY;
				if(atoi(radiusY)>0)
				{
					radY=atoi(radiusY)-atoi(radius_minY);
				}
				else
				{
					radY=radX;
				}
				int radZ;
				if(atoi(radiusZ)>0)
				{
					radZ=atoi(radiusZ)-atoi(radius_minZ);
				}
				else
				{
					radZ=0;
				}

				int tX=atoi(teilerX);
				if(tX<1){tX=1;}
				int tY;
				if(atoi(teilerY)>1)
				{
					tY=atoi(teilerY);
				}
				else
				{
					tY=tX;
				}
				int tZ;
				if(atoi(teilerZ)>1)
				{
					tZ=atoi(teilerZ);
				}
				else
				{
					tZ=tX;
				}

				if(tX>1||tY>1||tZ>1)
				{
					save<<sin(winkel*(Pi/180.0))*MyRandom(radX) / (float)tX;
					save<<" , "<<cos(winkel*(Pi/180.0))*MyRandom(radY) / (float)tY;
					if(radZ>0)
					{
						save<<" , "<<(cos(winkelZ*(Pi/180.0))*sin(winkel*(Pi/180.0))*cos(winkel*(Pi/180.0)))*MyRandom(radZ) / (float)tZ;
					}
				}
				else
				{
					save<<round(sin(winkel*(Pi/180.0))*MyRandom(radX));
					save<<" , "<<round(cos(winkel*(Pi/180.0))*MyRandom(radY));
					if(radZ>0)
					{
						save<<" , "<<round((cos(winkelZ*(Pi/180.0))*sin(winkel*(Pi/180.0))*cos(winkel*(Pi/180.0)))*MyRandom(radZ));
					}
				}
			}
*/
/*
			else if(Z==markerR[0])
			{
				double winkel=(double)(urandom()%36000000)/100000.0;
				double winkelZ=(double)(urandom()%36000000)/100000.0;

				int radX=atoi(radiusX)-atoi(radius_minX);
				if(radX<1){radX=1;}
				int radY;
				if(atoi(radiusY)>0)
				{
					radY=atoi(radiusY)-atoi(radius_minY);
				}
				else
				{
					radY=radX;
				}
				int radZ;
				if(atoi(radiusZ)>0)
				{
					radZ=atoi(radiusZ)-atoi(radius_minZ);
				}
				else
				{
					radZ=0;
				}

				int tX=atoi(teilerX);
				if(tX<1){tX=1;}
				int tY;
				if(atoi(teilerY)>1)
				{
					tY=atoi(teilerY);
				}
				else
				{
					tY=tX;
				}
				int tZ;
				if(atoi(teilerZ)>1)
				{
					tZ=atoi(teilerZ);
				}
				else
				{
					tZ=tX;
				}

				if(tX>1||tY>1||tZ>1)
				{
					save<<sin(winkel*(Pi/180.0))*(urandom()%radX + atoi(radius_minX)) / (double)tX;
					save<<" , "<<cos(winkel*(Pi/180.0))*(urandom()%radY + atoi(radius_minY)) / (double)tY;
					if(radZ>0)
					{
						save<<" , "<<(cos(winkelZ*(Pi/180.0))*sin(winkel*(Pi/180.0))*cos(winkel*(Pi/180.0)))*(urandom()%radZ + atoi(radius_minZ)) / (double)tZ;
					}
				}
				else
				{
					save<<round(sin(winkel*(Pi/180.0))*(urandom()%radX + atoi(radius_minX)));
					save<<" , "<<round(cos(winkel*(Pi/180.0))*(urandom()%radY + atoi(radius_minY)));
					if(radZ>0)
					{
						save<<" , "<<round((cos(winkelZ*(Pi/180.0))*sin(winkel*(Pi/180.0))*cos(winkel*(Pi/180.0)))*(urandom()%radZ + atoi(radius_minZ)));
					}
				}
			}

*/
/*			else if(Z==markerR[0])
			{
				float winkel=(float)(urandom()%36000000)/100000.0;
				float winkelZ=(float)(urandom()%36000000)/100000.0;

				int radX=atoi(radiusX)-atoi(radius_minX);
				if(radX<1){radX=1;}
				int radY;
				if(atoi(radiusY)>0)
				{
					radY=atoi(radiusY)-atoi(radius_minY);
				}
				else
				{
					radY=radX;
				}
				int radZ;
				if(atoi(radiusZ)>0)
				{
					radZ=atoi(radiusZ)-atoi(radius_minZ);
				}
				else
				{
					radZ=0;
				}

				int tX=atoi(teilerX);
				if(tX<1){tX=1;}
				int tY;
				if(atoi(teilerY)>1)
				{
					tY=atoi(teilerY);
				}
				else
				{
					tY=tX;
				}
				int tZ;
				if(atoi(teilerZ)>1)
				{
					tZ=atoi(teilerZ);
				}
				else
				{
					tZ=tX;
				}

				if(tX>1||tY>1||tZ>1)
				{
					save<<sin(winkel*(Pi/180.0))*(urandom()%radX + atoi(radius_minX)) / (float)tX;
					save<<" , "<<cos(winkel*(Pi/180.0))*(urandom()%radY + atoi(radius_minY)) / (float)tY;
					if(radZ>0)
					{
						save<<" , "<<(cos(winkelZ*(Pi/180.0))*sin(winkel*(Pi/180.0))*cos(winkel*(Pi/180.0)))*(urandom()%radZ + atoi(radius_minZ)) / (float)tZ;
					}
				}
				else
				{
					save<<round(sin(winkel*(Pi/180.0))*(urandom()%radX + atoi(radius_minX)));
					save<<" , "<<round(cos(winkel*(Pi/180.0))*(urandom()%radY + atoi(radius_minY)));
					if(radZ>0)
					{
						save<<" , "<<round((cos(winkelZ*(Pi/180.0))*sin(winkel*(Pi/180.0))*cos(winkel*(Pi/180.0)))*(urandom()%radZ + atoi(radius_minZ)));
					}
				}
			}
*/
			else if(Z==markerR[0])
			{
				double winkel=(double)(rand()%36000000)/100000.0;
				double winkelZ=(double)(rand()%36000000)/100000.0;

				int radX=atoi(radiusX)-atoi(radius_minX);
				if(radX<1){radX=1;}
				double rad_faktorY=1;
				if(atoi(radiusY)>0)
				{
					rad_faktorY=(double)(radX/(atoi(radiusY)-atoi(radius_minY)));
				}
				double rad_faktorZ=1;
				if(atoi(radiusZ)>0)
				{
					rad_faktorZ=(double)(radX/(atoi(radiusZ)-atoi(radius_minZ)));
				}

				int tX=atoi(teilerX);
				if(tX<1){tX=1;}
				int tY;
				if(atoi(teilerY)>1)
				{
					tY=atoi(teilerY);
				}
				else
				{
					tY=tX;
				}
				int tZ;
				if(atoi(teilerZ)>1)
				{
					tZ=atoi(teilerZ);
				}
				else
				{
					tZ=tX;
				}

				double radius=(rand()%radX + atoi(radius_minX));
				if(tX>1||tY>1||tZ>1)
				{
					save<<(sin(winkel*(Pi/180.0)) * radius) / (double)tX;
					save<<" , "<<((cos(winkel*(Pi/180.0))/rad_faktorY) * radius) / (double)tY;
					if(rad_faktorZ!=1)
					{
						save<<" , "<<(((cos(winkelZ*(Pi/180.0))/rad_faktorZ)*sin(winkel*(Pi/180.0))*(cos(winkel*(Pi/180.0))/rad_faktorY)) * radius) / (double)tZ;
					}
				}
				else
				{
					save<<sin(winkel*(Pi/180.0)) * radius;
					save<<" , "<<(cos(winkel*(Pi/180.0))/rad_faktorY) * radius;
					if(rad_faktorZ!=1)
					{
						save<<" , "<<((cos(winkelZ*(Pi/180.0))*sin(winkel*(Pi/180.0))*cos(winkel*(Pi/180.0)))/rad_faktorZ) * radius;
					}
				}
			}

			else
			{
				save<<Z;
			}
		}
		else
		{
// nach stdout
			if(Z==marker1[0])
			{
				if(atoi(teiler1)>1)
				{
					printf("%f",(float)(rand()%atoi(bereich1) + atoi(bereich2)) / atoi(teiler1));
				}
				else
				{
					printf("%i",rand()%atoi(bereich1) + atoi(bereich2));
				}
			}
			else if(Z==marker2[0])
			{
				if(atoi(teiler2)>1)
				{
					printf("%f",(float)(rand()%atoi(bereich3) + atoi(bereich4)) / atoi(teiler2));
				}
				else
				{
					printf("%i",rand()%atoi(bereich3) + atoi(bereich4));
				}
			}
			else if(Z==marker3[0])
			{
				if(atoi(teiler3)>1)
				{
					printf("%f",(float)(rand()%atoi(bereich5) + atoi(bereich6)) / atoi(teiler3));
				}
				else
				{
					printf("%i",rand()%atoi(bereich5) + atoi(bereich6));
				}
			}
			else
			{
				printf("%c",Z);
			}
		}
	}




// Fertig
	load.close();
	if(!stdout)
	{
		save.close();
	}
}


















// Funktionen --------------------------------------------------------------------------------------
void Bedienung()
{
	printf("\nz2z:                              Version %s\n------------------------------------------------\n",VERSION);
	printf("Dieses Programm ersetzt alle gefundenen ""Marker-Zeichen"" durch Zufalls-Zahlen.\n");
	printf("Man kann bis zu 3 Zeichen gleichzeitig ersetzen.\n\n");
	printf("Die Marker (-m/-n/-o) duerfen dabei nur aus einem Zeichen bestehen.\n");
	printf("  (Achten Sie darauf, dass die Marker in der Quelldatei nur an den Stellen\n");
	printf("   vorkommen, die auch ersetzt werden sollen.)\n\n");
	printf("Die Bereiche werden mit 1 oder 2 Werten angegeben (-1/-3/-5 und -2/-4/-6)\n");
	printf("Sie koennen fuer fuer jeden Bereich auch einen Teiler (-t/-u/-v) angeben, um\n");
	printf("Kommazahlen zu erzeugen.\n");
	printf("Die Bedeutung der Werte ist:\n");
	printf("  ( rand()%% wert1 + wert2 ) / teiler1\n");
	printf("z.B.\n");
	printf("  z2z -m [ -1 1000 -2 -500\n");
	printf("  ersetzt alle >[< Zeichen durch Zufallszahlen im Bereich von -500 bis 499.\n");
	printf("  z2z -m [ -1 1000 -2 -500 -t 10\n");
	printf("  ersetzt alle >[< Zeichen durch Zufallszahlen im Bereich von -50.0 bis 49.9.\n\n");
	printf("Der zweite Wert (-2/-4/-6) kann weggelassen werden.\n");
	printf("z.B.\n");
	printf("  z2z -m [ -1 1000\n");
	printf("  ersetzt alle >[< Zeichen durch Zufallszahlen im Bereich von 0 bis 999.\n");
	printf("  z2z -m [ -1 1000 -t 10\n");
	printf("  ersetzt alle >[< Zeichen durch Zufallszahlen im Bereich von 0 bis 99.9.\n\n\n");
	printf("Optionen:\n----------\n");
	printf("-h | --help             | Diese Kurzhilfe\n");
	printf("-q | --quelldatei NAME  | Quell-Dateiname\n");
	printf("-z | --zieldatei NAME   | Ziel-Dateiname\n");
	printf("                          (Wird der Ziel-Dateiname nicht angegeben,\n");
	printf("                           wird auf stdout ausgegeben.)\n\n");
	printf("-m | --marker1 ZEICHEN  | zu ersetzendes Zeichen1 (nur eines)\n");
	printf("-1 | --bereich1 WERT    | Bereich1 der Zufallszahlen\n");
	printf("-2 | --bereich2 WERT    | Bereich2 der Zufallszahlen\n");
	printf("-t | --teiler1 WERT     | Teiler1 der Zufallszahlen\n\n");
	printf("-n | --marker2 ZEICHEN  | zu ersetzendes Zeichen2 (nur eines)\n");
	printf("-3 | --bereich3 WERT    | Bereich3 der Zufallszahlen\n");
	printf("-4 | --bereich4 WERT    | Bereich4 der Zufallszahlen\n");
	printf("-u | --teiler2 WERT     | Teiler2 der Zufallszahlen\n\n");
	printf("-o | --marker3 ZEICHEN  | zu ersetzendes Zeichen3 (nur eines)\n");
	printf("-5 | --bereich5 WERT    | Bereich5 der Zufallszahlen\n");
	printf("-6 | --bereich6 WERT    | Bereich6 der Zufallszahlen\n");
	printf("-v | --teiler3 WERT     | Teiler3 der Zufallszahlen\n\n");

	exit(1);
}








/*
void urandom_init()
{
	urandom_fd = open("/dev/urandom", O_RDONLY);

	if (urandom_fd == -1)
	{
		int errsv = urandom_fd;
		printf("Error opening [/dev/urandom]: %i\n", errsv);
		exit(1);
	}
}







unsigned long urandom()
{
	unsigned long buf_impl;
	unsigned long *buf = &buf_impl;

	if(urandom_fd==-2)
	{
		urandom_init();
	}

// Read 4 bytes, or 32 bits into *buf, which points to buf_impl
	read(urandom_fd, buf, sizeof(long));
	return buf_impl;
}
*/






float MyRandom( float Bereich )
{
  float rNum = ( (float) rand() / (float) RAND_MAX ) * Bereich;
  return rNum;
}








void test()
{
//	srandom(time(0));
	for (int z=0;z<10000;z++)
	{
		printf("%i\n",rand()%360);
//		printf("%li\n",urandom()%360);
	}
	exit(0);
}