Index: cpp/f8-to-f1/conv_f8tof1.cpp
===================================================================
--- cpp/f8-to-f1/conv_f8tof1.cpp	(revision 25)
+++ cpp/f8-to-f1/conv_f8tof1.cpp	(revision 26)
@@ -366,5 +366,5 @@
 	SString s = SString::valueOf(params[0]);
 #if CONV_DEBUG > 1
-	cout << "@@@@@ Wartosc parametru: " << this->paramName << ": " << params[0] << endl;
+	cout << "@@@@@ Param value: " << this->paramName << ": " << params[0] << endl;
 #endif
 	return s;
@@ -414,9 +414,6 @@
 }
 
-/**
- * Zwracamy puste, bo co innego mamy zrobić?
- */
 const SString Production::getF1Genotype(const vector<double> params) {
-	return SString("");
+	return SString(); //return empty
 }
 
@@ -430,5 +427,5 @@
 	}
 	
-	//jedziemy po podprodukcjach
+	//iterate through subproductions
 	for (vector<SubProduction>::iterator subProdIter = this->subproductions.begin();
 		 subProdIter != this->subproductions.end(); subProdIter++) {
@@ -438,9 +435,9 @@
 		SubProduction &sp = *subProdIter;
 		bool conditionsOK = true;
-		//sprawdzenie warunków dla danej podprodukcji
+		//check conditions of subproduction
 		for (vector<Condition>::iterator condIter = sp.conditions.begin();
 			 condIter != sp.conditions.end(); condIter++) {
 			if (conditionsOK == false) {
-				break; //bo dalsze sprawdzanie i tak nie ma sensu
+				break; //because it's no use checking further
 			}
 			Condition &c = *condIter;
@@ -479,5 +476,5 @@
 		}
 		if (conditionsOK) {
-			//jedziemy po każdej akcji w danej podprodukcji
+			//iterate through each action in subproduction
 			for (int i = 0; i < sp.actions.size(); i++) {
 #if CONV_DEBUG > 1
@@ -487,5 +484,5 @@
 				vector<SString> strParams = sp.actions[i].params;
 				vector<double> params;
-				//podmieniamy nazwy parametrów na ich wartości
+				//replace parameter names with values
 				for (vector<SString>::iterator paramIter = strParams.begin();
 					 paramIter != strParams.end(); paramIter++) {
@@ -527,5 +524,5 @@
 	while (in.getNextToken(pos, line, '\n')) {
 #if CONV_DEBUG > 1
-		std::cout << "### Linia: " << line << std::endl;
+		std::cout << "### Line: " << line << std::endl;
 #endif
 		if (line.startsWith("P") && line.indexOf('(', 0) == -1) {
@@ -540,5 +537,5 @@
 			SString prodName = line.substr(0, lParenIndex);
 #if CONV_DEBUG > 1
-			std::cout << "###Produkcja: " << prodName << std::endl;
+			std::cout << "###Production: " << prodName << std::endl;
 #endif
 			names.push_back(prodName);
@@ -599,5 +596,5 @@
 	
 	//cout << "convert() 1" << endl;
-	//ustawienie zmiennych dla początkowej produkcji
+	//set parameters for start production
 	Production *firstProduction = lsystem->productions[lsystem->firstProductionName];
 	vector<double> params;
@@ -674,5 +671,5 @@
 	Lsystem *lsys = new Lsystem();
 	
-	//wczytujemy nazwy produkcji i tworzymy wstępnie dla nich obiekty
+	//read production names and create objects for them
 	vector<SString> names = this->readProductionNames(in);
 	for (vector<SString>::iterator nameIter = names.begin(); nameIter != names.end(); nameIter++) {
@@ -699,5 +696,5 @@
 #if CONV_DEBUG > 1
 	
-	cout << "@@@@@ Przeparsowane" << endl;
+	cout << "@@@@@ Parsed" << endl;
 	
 	cout << "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" << endl;
@@ -726,5 +723,5 @@
 
 bool GenoConv_F8ToF1::parseInput(const char* src, Lsystem* lsys) {
-	//inicjalizacja zmiennych parsera
+	//initialize parser
 	int yv;
 	istringstream input;
@@ -739,5 +736,5 @@
 	extern YYSTYPE yylval;
 	
-	//parsowanie wejścia
+	//parse input
 	// on EOF yylex will return 0
 	while((yv = scanner.yylex()) != 0) {
Index: cpp/f8-to-f1/conv_f8tof1.h
===================================================================
--- cpp/f8-to-f1/conv_f8tof1.h	(revision 25)
+++ cpp/f8-to-f1/conv_f8tof1.h	(revision 26)
@@ -43,16 +43,25 @@
 };
 
-class ActionP;
-
+class ActionP; //only declaration
+
+/// superclass of all actions, e.g. Production, PrimitiveProduction etc.
 class Action {
 public:
+	/// action's name
 	SString name;
+	/// if true action should ignore params passed to it
 	bool ignoreParams;
+	/// gets string representaion of this action in f1 format
 	virtual const SString getF1Genotype(vector<double> params) = 0;
+	/// gets list of actions with double parameters to each of them
+	/// @param params parameters passed to this action
 	virtual const list<ActionP> getActionList(const vector<double> params) = 0;
+	/// gets string representaion of this action in f8 format
 	virtual const SString getF8Representation() = 0;
 	virtual ~Action() {}
 };
 
+/// this class consists of pointer to some action and a list of parameters to that action;
+/// parameters are kept as strings
 class ActionStrP {
 public:
@@ -61,4 +70,6 @@
 };
 
+/// this class consists of pointer to some action and a list of parameters to that action;
+/// parameters are kept as doubles
 class ActionP {
 public:
@@ -67,10 +78,15 @@
 };
 
+/// part of production which is used in translation only if all the conditions are met
 class SubProduction {
 public:
+	/// list of conditions necessary to be met
 	vector<Condition> conditions;
+	/// actions with params (as strings)
 	vector<ActionStrP> actions;
 };
 
+/// primitive production; it's directly translated to its f1 equivalent
+/// e.g. X, r, R etc.
 class PrimitiveProduction : public Action {
 public:
@@ -84,4 +100,6 @@
 };
 
+/// param production; all param productions during translation are replaced with the current value of parameter
+/// pointed by this production
 class ParamProduction : public Action {
 public:
@@ -94,4 +112,5 @@
 };
 
+/// neuron production; it is directly translated to f1 without any change
 class NeuronProduction : public Action {
 public:
@@ -104,19 +123,43 @@
 };
 
-/**
- * Pozycje liczone od 1 a nie od 0!
- */
+/// class which keeps all parameters of a production and enables to access them in convenient way
+/// IMPORTANT! All indices (positions) begins with 1 (not 0)!
 class ParameterCollection {
 public:
+	/// returns parameter's value
+	/// @param position parameter's position (first parameter has an index 1!)
 	const double getValue(int position);
+	/// returns parameter's value
+	/// @param name parameter's name
 	const double getValue(SString name);
+	/// returns parameter's name
+	/// @param position parameter's position (first parameter has an index 1!)
 	const SString getParameterName(int position);
-	const int getParameterPosition(SString name); //zwróci index liczony od 1!
+	/// returns parameter's position (first parameter has an index 1!)
+	/// @param name parameter's name
+	const int getParameterPosition(SString name);
+	/// sets parameter's value
+	/// @param position parameter's position
+	/// @param value parameter's new value
 	void setValue(int position, double value);
+	/// sets parameter's value
+	/// @param name parameter's name
+	/// @param value parameter's new value
 	void setValue(SString name, double value);
+	/// adds parameter
+	/// @param name parameter's name
+	/// @param position desired parameter's position; defualts to -1 which means it will have first available position
+	/// @param value parameter's value; defaults to 0.0
 	void addParameter(SString name, int position = -1, double value = 0.0);
+	/// returns the number of parameters kept in this class
 	const int size();
+	/// removes a parameter
+	/// @param position position of parameter to be deleted
 	void removeParameter(int position);
+	/// removes a parameter
+	/// @param name name of parameter to be deleted
 	void removeParameter(SString name);
+	/// returns true if parameter with given name exists
+	/// @param name parameter's name
 	bool paramExist(SString name);
 protected:
@@ -125,7 +168,11 @@
 };
 
+/// represents a general rule in L-systems
+/// only "calls" to Production in genotype are replaced in translation procedure
 class Production : public Action {
 public:
+	/// parameters of this production
 	ParameterCollection parameters;
+	/// list of subproductions
 	vector<SubProduction> subproductions;
 	
@@ -137,17 +184,33 @@
 };
 
+/// Main class that represents a genotype in f8 format
 class Lsystem {
 public:
+	/// number of iterations in f8->f1 translation procedure
 	int iterations;
+	/// map of parameters of start production; key - parameter's name, value - parameter's value
 	map<string, double> startParams;
+	/// map of productions of L-system; key - productions's name, value - pointer to production
 	map<string, Production*> productions;
+	/// collection of neuron productions held in L-system
 	vector<NeuronProduction*> neuronProductions;
+	/// first production's name
 	string firstProductionName;
 	
 	Lsystem();
 	~Lsystem();
+	/// returns a primitive production of a given name
+	/// @param name primitive production's name
 	PrimitiveProduction* getPrimitiveProduction(SString name);
+	/// returns a param production of a given name
+	/// @param name param production's name
 	ParamProduction* getParamProduction(SString name);
+	/// gets string representation of this L-system (f8 genotype)
 	SString toString();
+	/// returns all actions
+	/// @param normal if true all normal actions will be included
+	/// @param primitives if true all primitive actions will be included
+	/// @param params if true all param actions will be included
+	/// @param neurons if true all neuron actions will be included
 	vector<Action*> getAllActions(bool normal, bool primitives, bool params, bool neurons);
 protected:
@@ -158,6 +221,8 @@
 };
 
+/// Converter between f8 and f1 format
 class GenoConv_F8ToF1 : public GenoConverter {
 public:
+	/// Default constructor
 	GenoConv_F8ToF1() {
 		name = "f8 to f1 converter";
@@ -169,4 +234,6 @@
 	}
 	
+	/// Constructor with parameter
+	/// @param f1LengthLimit If resulting f1 genotype is longer than f1LengthLimit, converter aborts its job
 	GenoConv_F8ToF1(int f1LengthLimit) {
 		name = "f8 to f1 converter";
@@ -181,7 +248,16 @@
 	
 	SString convert(SString &in, MultiMap *map);
+	
+	/// check syntax of given f8 genotype
+	/// @param geno f8 genotype to be checked
 	bool checkSyntax(const char *geno);
+	
+	/// returns names of productions in a given genotype
+	/// @param in f8 genotype
 	vector<SString> readProductionNames(const SString &in);
 	//Lsystem* createLsystem(const SString &in);
+	
+	/// creates Lsystem object based on input genotype
+	/// @param f8 genotype
 	Lsystem* createLsystem(SString in);
 protected:
